por Leandro Cissoto
E aqui estamos nós com mais um da série de 10 posts Quaddro + MacMagazine sobre Swift. Hoje vamos falar sobre Tuplas e Condicionais. Também teremos mais um exercício guiado e mais um desafio.
Lembrando sempre que, para testar os conceitos aqui apresentados, recomendamos o uso do Xcode 6 ou superior.
Se você não possui um Mac ou não quer instalar o Xcode, é possível utilizar uma ferramenta online que permite escrever em Swift diretamente pelo navegador. Agora não há mais desculpas para não começarmos a programar em Swift! 😉
Teoria
Agora que vimos os principais tipos de variáveis, operadores e Collection Types, nada mais justo do que começarmos a utilizar os famosos condicionais para colocar lógicas mais complexas em nosso código. De quebra vamos ver as tuplas, uma das grandes (e boas!) novidades da Swift.
Tuplas
Tuplas, em Swift, são um tipo composto. Podemos dizer que uma tupla poderia ser um Collection Type, como um Array, mas de forma mais simplificada, possibilitando que uma variável possa ter vários valores diferentes, e estes valores podem ser acessados por uma chave.
Exemplo:
var tupla = ("Leandro", "Danilo", "Amanda")
Resultado:
tupla: (String, String, String) = { 0 = "Leandro" 1 = "Danilo" 2 = "Amanda" }
Para que possamos acessar o valor de uma tupla, indicamos o nome da variável seguida de seu índice. Assim como no array, o índice inicial da tupla é 0
. Veja o exemplo abaixo utilizando a tupla declarada no exemplo anterior.
println("O meu nome é \(tupla.0)") println("O meu nome dele é \(tupla.1)") println("O meu nome dela é \(tupla.2)")
Diferentemente dos Arrays, as tuplas podem guardar valores de diferentes tipos.
Exemplo:
var parceria = ("Quaddro + MacMagazine", 300, 40, 87.3)
Resultado:
parceria: (String, Int, Int, Double) = { 0 = "Quaddro + MacMagazine" 1 = 300 2 = 40 3 = 87.299999999999997 }
A Swift permite declararmos tuplas atribuindo nomes aos seus elementos.
Exemplo:
var opala = (cilindros: "6 cilindros em linha", potencia: 135 )
Resultado:
opala: (cilindros: String, potencia: Int) = { cilindros = “6 cilindros em linha” potencia = 135 }
Acessamos os valores de uma tupla de forma semelhante a como acessamos propriedades de uma classe, utilizando o caractere .
— como no exemplo abaixo:
opala.cilindros opala.potencia
Também podemos decompor uma tupla em variáveis.
Exemplo:
var (x, y) = opala
Onde a variável x
irá receber o valor de cilindros e a variável y
irá receber o valor de potência.
Resultado:
x: String = "6 cilindros em linha" y: Int = 135
Podemos ignorar algum valor no momento da decomposição de uma tupla utilizando o caracetere _
(underscore).
Exemplo:
var (_, b) = opala
Desta forma, o único elemento acessado da tupla será o valor da potência, que sera atribuído à variável b
.
Condicionais
Finalmente chegamos aos famosos condicionais, conteúdo extremamente importante para quase qualquer linguagem de programação. Para quem é marinheiro de primeira viagem em programação, podemos dizer que os condicionais são uma forma de determinarmos rumos diferentes para a execução de um programa.
Todas as vezes que pensamos na execução de um programa e “verbalizamos” as expressões “caso isso aconteça” ou “se a resposta for verdadeira”, estamos falando de condicionais.
A partir de agora, nossos programas ganharão outro nível de recursos e complexidade, pois condicionais farão parte frequente dos nossos playgrounds. 🙂
if
, else
e else if
Um dos condicionais mais utilizados é o famoso if
/else
, que é composto basicamente de três partes.
- A palavra
if
seguida de uma expressão (entenda como uma pergunta) que resulte em verdadeiro ou falso (ou seja, um booleano). - Um escopo entre chaves que é executado caso a resposta da expressão seja verdadeira.
- Opcionalmente podemos ter a palavra
else
, seguida de um escopo entre chaves caso a resposta da expressão seja falsa.
Na pratica, fica assim:
if expressao { //Bloco de código caso a expressão seja verdadeira } else { //Bloco de código caso a expressão seja falsa }
Exemplo:
if 0 > 3 { println("O primeiro numero da expressão é maior que o segundo") } else { println("O segundo numero é maior ou igual ao primeiro") }
Nota: o bloco else
não é obrigatório, permitindo que utilizemos apenas o if
, dependendo da lógica da nossa aplicação.
Podemos também aninhar várias expressões para obtermos sub-resultados baseados no escopo em que estão.
Exemplo:
var num = 7 if num >= 7 { if num == 10 { println("Aluno exemplar") } else { println("Bom aluno") } } else { println("Aluno abaixo da média") }
Resultado:
Bom aluno
Às vezes precisamos utilizar mais de uma condição em uma mesma estrutura. Para isso utilizamos else if
, que executa uma outra expressão no caso de as anteriores serem falsas.
O exemplo abaixo é uma forma semelhante à do exemplo anterior, mas de forma simplificada:
var num = 7 if num == 10 { println("Aluno exemplar") } else if num >= 7 { println("Bom Aluno") } else { println("Aluno abaixo da média") }
Operadores AND e OR
Também conhecidos como operadores condicionais ou lógicos, os operadores AND e OR servem para complementar o estudo do if
/else
em casos nos quais mais de uma condição é necessária para decidir o rumo do código. Vamos detalhar a sua sintaxe.
Utilizamos &&
(AND) quando desejamos quando desejamos que uma ou mais condições seja verdadeira em uma determinada expressão.
Exemplo:
var numeroCupom = 40402 var horario = 10 if numeroCupom == 40402 && horario < 10 { println("Desconto concedido") } else { println("Não foi possível conceder o desconto") }
Resultado:
Não foi possível conceder o desconto
Vamos fazer a leitura em português da expressão acima para entendermos por que ela é falsa. "Se numeroCupom
for igual a 40402
e horario
for menor do que 10
, execute o bloco."
Para mudarmos isso, poderíamos fazer o seguinte:
if numeroCupom == 40402 && horario <= 10 { println("Desconto concedido") } else { println("Não foi possível conceder o desconto") }
Resultado:
Desconto concedido
Neste caso as duas condições são verdadeiras, portanto o bloco if
é executado. Fazendo a leitura em português, ficaria assim: "Se numeroCupom
for igual a 40402
e horario
for menor ou igual que 10
, execute o bloco."
Agora, sim, temos uma expressão verdadeira.
Utilizamos ||
(OR) quando desejamos que ao menos uma condição seja verdadeira dentro de uma expressão.
Exemplo:
if numeroCupom == 40402 || horario < 10 { println("Desconto concedido") } else { println("Não foi possível conceder o desconto") }
Resultado:
Desconto concedido
Neste caso basta apenas que uma das duas condições seja verdadeira para que toda a expressão seja validada. Se formos fazer a leitura da expressão em português, ficaria assim: "Se numeroCupom
for igual a 40402
ou horario
for menor do que 10
, execute o bloco."
Pode parecer um pouco confuso a princípio, mas se fizermos a leitura em português da expressão, fica mais simples de compreender como ela funciona.
Nota: é possível inserir os operadores &&
e ||
em uma mesma expressão, como veremos mais adiante no nosso exercício guiado.
switch
A estrutura condicional switch
funciona de forma muito semelhante ao if
/else
. A diferença é a facilidade de fazer comparações sucessivas. Se tivermos, por exemplo, que comparar um valor com três possíveis respostas, a abordagem switch
seria mais indicada, pois sua estrutura permite comparações encadeadas de maneira mais organizada, onde várias hipóteses podem ser verificadas sucessivamente.
Podemos separar um switch
em 4 partes principais:
- A palavra reservada
switch
, e uma expressão. - Um escopo definido entre chaves, onde serão definidos os possíveis valores.
- Cada valor é definido através de um identificador
case
, seguido dos comandos, caso a hipótese seja verdadeira. - Se nenhuma hipótese contém o valor da expressão válido, será executado o bloco
default
, que representa um contexto de “Nenhuma das alternativas anteriores”.
Exemplo:
var nome = "Roberto" switch nome { case "Amandita": println("É a Amanda Mummy") case "Roberto": println("É o grande parceiro Roberto") case "Danilo": println("É o Daniloso...") case "Trovilho": println("Grande Trovilhada") default: println("Deve ser outra pessoa que não conheço =)") }
Nota: a Swift, diferentemente da maioria das linguagens que possui o condicional switch
, não obriga o programador a utilizar o comando break
para interromper a execução do bloco condicional.
Exercício guiado
Agora que conhecemos um pouco mais sobre tuplas e condicionais, vamos fazer alguns exercícios para compreender sua utilização, de modo que agora será possível darmos mais "caminhos" para o nosso código.
- Crie um novo Playground com o nome “TuplasCondicionais” e limpe todo o projeto.
- Vamos criar uma tupla chamada
triangulo
, que irá receber os valores decatOposto
,catAdjacente
ehipotenusa
.
//Criando um triângulo var triangulo = (catOposto: 52, catAdjacente: 13, hipotenusa: 65) //Acessando os objetos pelos nomes triangulo.catOposto triangulo.catAdjacente triangulo.hipotenusa
- Vamos utilizar um condicional para vermos se
triangulo
é retângulo ou não. Lembrando que um triângulo retângulo possui o quadrado da hipotenusa igual à soma dos quadrados dos catetos. Vamos utilizar os índices da tupla em vez dos seus nomes. Lembrando que as tuplas seguem a mesma regra que o Array: o primeiro elemento sempre está no índice0
.
//Verificando se o triângulo é retângulo if (triangulo.2 * triangulo.2) == (triangulo.1 * triangulo.1) + (triangulo.0 * triangulo.0) { println("É um triangulo retangulo") }else{ println("Não é um triangulo retângulo") }
Neste momento, o nosso código está assim:
- Vamos testar outro exemplo, colocando as notas de um aluno em uma tupla e verificamos se o aluno passou de ano. Para isso vamos criar uma variável chamada
mediaEscola
, para termos uma base para calcularmos. Faremos uso doelse if
para verificarmos se o aluno passou em cima da média.
//Média da escola var mediaEscola = 6.0 //Notas do bimestre var notas = (bim1: 5.3, bim2: 7.0, bim3: 6.0, bim4: 7.0) //Média do aluno let mediaAluno = (notas.bim1 + notas.bim2 + notas.bim3 + notas.bim4) / 4 if mediaAluno > mediaEscola{ println("Passou com louvor") }else if mediaAluno == mediaEscola { println("NA TRAVEEE!") }else{ println("Não passou") }
- Vamos supor que a escola tenha criado um sistema de recuperação, em que o aluno que não atingiu a média pode fazer uma prova extra para tentar recuperar a média. A recuperação considera a soma da média dos bimestres mais a nota da prova, divido por
2
. Se o valor for maior do que5
, o aluno é aprovado. Isso vai nos obrigar a criar mais um item na tupla, chamadorec
, e uma nova condição na dentro doelse
.
//Média da escola var mediaEscola = 6.0 //Notas do bimestre var notas = (bim1: 5.3, bim2: 5.6, bim3: 6.0, bim4: 7.0, rec: 0.0) //Média do aluno let mediaAluno = (notas.bim1 + notas.bim2 + notas.bim3 + notas.bim4) / 4 if mediaAluno > mediaEscola{ println("Passou com louvor") }else if mediaAluno == mediaEscola { println("NA TRAVEEE!") }else{ notas.rec = 5.6 let mediaRec = (notas.rec + mediaAluno) / 2 if(mediaRec >= 5.0){ println("Passou na recuperação") }else{ println("Repetiu de ano :(") } }
Nesse momento, o nosso código está assim:
- Vamos utilizar um
switch
fazendo uma brincadeira com as cores do Ano Novo.
/*-----Cores do Ano Novo----*/ var cor = "vermelho" switch cor { case "rosa": println("Rosa é a cor do amor") case "vermelho": println("Vermelho é a cor da paixão") case "amarelo": println("Amarelo é a cor do dinheiro. $$$$") case "branco": println("Branco é a cor da paz") default: println("Você não é uma pessoa supersticiosa ") }
- Vamos testar os operadores lógicos junto das condições. Perceba que nos comentários escrevemos a expressão da maneira que ela deve ser lida. Assim fica mais simples de construirmos condições mais complexas.
/*-----operadores lógicos------*/ var nome = "Leandro" var sobrenome = "Cissoto" //Se o nome for igual a Leandro E Sobrenome for igual a Cissoto OU Ramos if nome == "Leandro" && (sobrenome == "Cissoto" || sobrenome == "Ramos"){ println("É o Leandro Cissotagem") //Se o nome for igual a Danilo E o sobrenome for igual a Altheman }else if nome == "Danilo" && sobrenome == "Altheman"{ println("É o Daniloso") //Se o nome for diferente de Leandro OU nome for diferente de danilo }else if nome != "Leandro" && nome != "Danilo" { println("Não é o Leandro C. e nem o Danilo A.") //Caso contrário }else{ println("Não sei quem é.") }
Neste momento, o nosso código está assim:
Desafio
Chegou o momento de colocar à prova o que aprendemos até agora. Aproveitando que vamos falar de desafio: criamos um email para que vocês possam enviar os desafios de vocês: mm@quaddro.com.br. Nossa intenção é dar uma atenção e uma força a mais para quem está dando os primeiros passos e tentando resolver. Veremos todos os exercícios enviados. 🙂
Chega de papo e vamos torrar alguns neurônios, porque o desafio de hoje não é fácil, não.
Desafio "Jogo da Velha"
OBJETIVO
Fazer um jogo da velha utilizando a linguagem Swift.
REQUISITOS
- Utilizar tuplas
- Utilizar
if
,else if
eelse
- Operadores lógicos
&&
(AND) e||
(OR) - Utilizar a função
println
para exibir os resultados
DICAS
- Lembre-se que um jogo da velha é uma matriz de 3 linhas com 3 colunas cada.
- Que tal criar as tuplas da seguinte forma?
let row0 = ("x", "o", "o") let row1 = ("o", "x", "o") let row2 = ("o", "o", "x")
- Um jogo da velha tem uma quantidade limitada condições para garantir o vencedor. Considere essas condições para montar as expressões.
Claro que é um jogo da velha simples, apenas para pegar o conceito. Quem sabe futuramente não fazemos um com maior apelo visual. 😉
· · ·
Os códigos-fonte deste artigo podem ser acessados no nosso GitHub, bem como uma sugestão de solução para o nosso desafio.
No próximo artigo, falaremos sobre controle de fluxo, os famosos loops. Até lá!