Quaddro + MacMagazine: Swift na prática — #2 Operadores

por Leandro Cissoto

Dando continuidade à nossa série com 10 tutoriais Quaddro + MacMagazine sobre Swift, no último post falamos um pouco sobre o Playground, variáveis, constantes e tipos de dados. Hoje, vamos falar de Operadores.

Lembrando 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 (sugestão do pessoal dos comentários no último post). Agora não há mais desculpas para não começarmos a programar em Swift.

Teoria

Todas as linguagens de programação possuem operadores, afinal, não faria sentido que elas existissem sem que pudéssemos realizar operações dentro delas. Entretanto, é preciso entender e diferenciar os tipos de operadores para um melhor aproveitamento da linguagem bem como quando utilizá-los.

Vamos dar uma visão geral sobre os operadores da Swift e suas aplicações.

Operadores de atribuição

Os operadores de atribuição, como o próprio nome diz, servem para associarmos valores. Eles funcionam exatamente como vimos no artigo passado, quando comentamos sobre variáveis e constantes. Utilizamos o caractere = para atribuirmos um valor.

Exemplo:

let nome = "Leandro Altheman"
var idade = 28
let numeros = (33, 192, 89)

Operadores aritméticos

Os operadores aritméticos são aqueles utilizados para realizarmos operações matemáticas como soma, subtração, multiplicação, divisão e resto da divisão.

Exemplo:

let soma = 2 + 2
//Resultado: 4

let subtração = 20 - 10
//Resultado: 10

let multiplicação = 250 * 5
//Resultado: 1250

let divisão = 400 / 4
//Resultado: 100

var restoDaDivisão = 33 % 5
//Resultado: 3

A Swift também é capaz de inverter o sinal de um determinado valor, bastando adicionar o sinal de menos (-) na frente do valor que deseja alterar, sem a necessidade de multiplicar o resultado por -1.

Exemplo:

var resto = 33 % 5
-resto
//Resultado: -3

Assim como na matemática tradicional, a Swift dá prioridade para a multiplicação, divisão e resto se colocarmos toda a operação sem um separador.

Exemplo:

10 + 20 * 50
//Resultado: 1010

Com base no exemplo anterior, se quisermos realizar a soma antes da multiplicação devemos colocar a operação entre parênteses, fazendo com que ela aconteça primeiro.

Exemplo:

(10 + 20) * 50
//Resultado: 1500

Operadores de incremento e decremento

Os operadores de incremento e decremento são unários que permitem adicionar ou subtrair o valor 1 a uma variável. São normalmente utilizados dentro de um laço de repetição. Para usarmos esses operadores, precisamos incluir os símbolos ++ ou -- na frente ou atrás dos valores.

A disposição dos símbolos em relação aos valores faz toda a diferença na forma como o operador vai funcionar.

Considere as variáveis abaixo para os exemplos da tabela tabela:

var x = 20
var y = 10

Operadores compostos

Operadores compostos são aqueles que utilizam o seu próprio valor junto a um operador aritmético e de atribuição para atribuir novos valores a um elemento.

Exemplo:

var num = 120
num += 10
//Resultado: a variável num passa a ter o valor 130.

var x = 39.6
x -= 15.1
//Resultado: a variável x passa a ter o valor 24.5.

var y = 32.5
y *= 2
//Resultado: a variável y passa a ter o valor 65.

var z = 20
z /= 2
//Resultado: a variável z passa a ter o valor 10.

var r = 33
r %= 5
//Resultado: a variável r passa a ter o valor 3.

Operadores de comparação

Os operadores de comparação, como o próprio nome diz, são utilizados para compararmos valores. Essas comparações podem ser de igualdade, diferença, tamanho e entre objetos, um booleano (true ou false).

Nota: o caractere ! é utilizado como operador de negação. De uma maneira simplista, é como se colocássemos a palavra "não" onde ele está sendo utilizado. Veremos mais detalhes no exercício guiado.

Exemplos:

var a = 3
var b = 6

a == b
//falso

a != b
//verdadeiro

a > b
//falso

a < b
//verdadeiro

a >= 1
//verdadeiro

a >= 4
//falso

a <= 1
//verdadeiro

a <= 3
//verdadeiro

a <= 0
//falso

Operadores ternários

Operadores ternários são utilizados quando queremos associar valores a uma variável ou constante, dependendo de uma determinada condição. Sua sintaxe é bastante simples:

(condição) ? ação verdadeira : ação falsa

Podemos dizer que um operador ternário é semelhante a uma estrutura condicional simples, onde é atribuído um valor diferente para caso a comparação seja verdadeira ou falsa.

Exemplo:

var nome = "Amanda Mummy"
var quem = (nome == "Amanda Mummy") ? "É a Amanda" : "Sei la quem é"

var valor = 5
var result = (valor >= 5) ? "Passou de ano" : "Não deu"

var verdade = true
var sera = (verdade == true) ? "É verdade mesmo" : "Não é verdade"

Exercício guiado

Agora que já aprendemos sobre operadores, vamos utilizar os conceitos apresentados em um exercício guiado. Recomendo digitar o código para fixar melhor o conteúdo. Quando digitamos, prestamos mais atenção aos detalhes do que estamos fazendo e, de alguma forma, aprendemos mais. 🙂

1. Abra o Xcode e inicie um novo Playground chamado “Operadores” e, como fizemos anteriormente, deixe o arquivo em branco.

2. Vamos declarar algumas variáveis usando os operadores de atribuição. Sem novidades até aqui.

3. Vamos brincar com os números usando operadores de atribuição. Adicione o código abaixo:

/*Trocando valores entre variáveis usando
Uma variável auxiliar*/
var temp = Int()

temp = a
a = b
b = c
c = temp

/* Veja que invertemos os valores usando os operadores de atribuição */
a
b
c

Poderíamos ter atribuído o valor diretamente nas variáveis, não gastando memória com a variável temp. Porém acho interessante mostrar como podemos trocar valores entre variáveis. Isso fará mais sentido quando chegarmos a estruturas de repetição. 😉

Neste momento, o nosso código encontra-se assim:

4. Seguindo a ordem da teoria, vamos adicionar alguns operadores aritméticos em nosso Playground. Adicione o código abaixo e fique a vontade para trocar valores, adicionar novos operadores e criar outras operações.

/* Operações matemáticas */
a + b - c

a * b - c

(a * (b - c)) + 15

a * b / c

//Media dos valores
let resultado = (a + b + c) / 3
println("A média das 3 variaveis é \(resultado)")

Dica: utilizamos \(valor) para inserirmos o valor de uma variável ou constante dentro de uma string.

5. Agora vamos brincar com os operadores de incremento e decremento. Para deixar as coisas mais organizadas, criarei mais 3 variáveis com valores diferentes, e vamos incrementar e decrementar esse valores para entendermos como estes operadores funcionam. Insira o código abaixo no seu projeto:

/* Operadores de incremento e decremento */
var x = 10
var y = 15
var z = 20

//Valor incrementado depois de exibir
x++
x

//Valor incrementado antes de exibir
++y
y

//Valor decrementando depois de exibir
z--
z

//Valor decrementando antes de exibir
--z
z

/*Decremento o valor de y e somo com z, que incrementa depois*/
--y + z++
z
y

//Incremento diversas vezes o valor de z
z++
z++
z++
z

Neste momento, esse trecho de código deve estar semelhante a este:

Dica: os operadores de incremento e decremento são muito utilizados no controle de fluxo, o famoso “loop” ou laço de repetição, como veremos em postagens futuras.

6. Vamos utilizar agora os operadores compostos para trabalharmos alguns valores.

/* Operadores compostos */
var velocidade = 35.6
println("A velocidade atual é \(velocidade)")

velocidade += 20
println("Aumentando a velocidade para \(velocidade)")

velocidade -= 40
println("Diminuindo a velocidade para \(velocidade)")

velocidade *= 2
println("Dobrando a velocidade para \(velocidade)")

velocidade /= 3
println("Reduzindo para \(velocidade)")

Veja como ficou:

7. Vamos criar algumas variáveis para utilizarmos os operadores de comparação. Adicione o código abaixo:

/* Operadores compostos */
var num = 10
var num2 = 30

//Fazemos comparações entre os valores
//Igual
num == num2
//Maior
num > num2
//Menor
num < num2
//Maior ou igual
num >= 10
//Menor ou igual
num <= 9
//Diferente de
num != num2

/* Podemos utilizar o caractere ! como negação, ou seja, se a operação resultar em um false, com o caractere !, se torna true, e vice e versa. Podemos ler o caractere ! como "não" para facilitar o entendimento*/

//Não falso
!(num == num2)

// Não falso
!(num > num2)

// Não Verdadeiro
!(num < num2)

//Não verdadeiro
!(num != num2)

Seu código deve estar semelhante a este:

8. Para finalizar, vamos trabalhar um pouco com os operadores ternários, que retornam uma determinada informação no caso de a operação ser verdadeira e outra no caso de ser falsa. Adicione o código abaixo e não esqueça de mexer nos valores para testar combinações diferentes. 🙂

/* Operadores ternários */

//Verificando o raio
let pi = 3.141592653589793
let circunferencia = 50.2
var raio = circunferencia / pi

var qualRaio = (raio > 12) ? "Raião" : "Rainho"

//Verificando a média de um aluno
var bim1 = 3.5, bim2 = 4.5, bim3 = 7.0, bim4 = 5.0
var mediaAluno = (bim1 + bim2 + bim3 + bim4) / 4
let mediaEscola = 6.0

var final = (mediaAluno > mediaEscola) ? "Aprovado" : "Reprovado"

Seu código deve estar assim:

·   ·   ·

Com isso, concluímos mais um exercício guiado utilizando praticamente todos os operadores básicos da Swift, faltando apenas os operadores lógicos, que veremos quando chegarmos a condicionais.
Lembramos que os fontes estão disponíveis em nosso GitHub.

No próximo artigo, vamos conhecer mais a fundo as Strings e os Collection Types, e começaremos com os desafios. Nos vemos semana que vem!