Quaddro + MacMagazine: Swift na prática #4 — Tuplas e Condicionais

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.

Xcode de Apple

Versão 15.3 (3.4 GB)
Requer o macOS 14.0 ou superior

Grátis Código QR

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.

1. A palavra if seguida de uma expressão (entenda como uma pergunta) que resulte em verdadeiro ou falso (ou seja, um booleano).
2. Um escopo entre chaves que é executado caso a resposta da expressão seja verdadeira.
3. 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:

1. A palavra reservada switch, e uma expressão.
2. Um escopo definido entre chaves, onde serão definidos os possíveis valores.
3. Cada valor é definido através de um identificador case, seguido dos comandos, caso a hipótese seja verdadeira.
4. 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.

1. Crie um novo Playground com o nome “TuplasCondicionais” e limpe todo o projeto.

2. Vamos criar uma tupla chamada triangulo, que irá receber os valores de catOposto, catAdjacente e hipotenusa.

//Criando um triângulo
var triangulo = (catOposto: 52, catAdjacente: 13, hipotenusa: 65)

//Acessando os objetos pelos nomes
triangulo.catOposto
triangulo.catAdjacente
triangulo.hipotenusa

3. 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 índice 0.

//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:

4. 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 do else 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")
}

5. 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 que 5, o aluno é aprovado. Isso vai nos obrigar a criar mais um item na tupla, chamado rec, e uma nova condição na dentro do else.

//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:

6. 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 ")
    
}

7. 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

1. Utilizar tuplas
2. Utilizar if, else if e else
3. Operadores lógicos && (AND) e || (OR)
4. 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á!