Swift: Operadores do Swift

Os operadores são os símbolos de cálculo no seu código. Esta lição aborda todos os operadores básicos do Swift e como usá-los de forma eficaz.

1. O Que Você Vai Aprender

• Operadores aritméticos: adição, subtração, multiplicação, divisão, resto
• Operadores de atribuição e atribuição composta
• Operadores de comparação e resultados booleanos
• Operadores lógicos: E, OU, NÃO
• O operador ternário e a conversão de tipo numérico

2. Uma História Real: Um Analista Financeiro

(1) O Problema: A Divisão de Int Perdeu Decimais, Quebrando um Relatório

Bob é analista financeiro em uma startup que precisava calcular o crescimento trimestral da receita. Ele escreveu este código:

let currentRevenue = 250_000
let previousRevenue = 200_000
let growthRate = (currentRevenue - previousRevenue) / previousRevenue * 100
print("Growth rate: \(growthRate)%")

Saída:

TEXT 📖 Somente leitura

📋 Copy

Growth rate: 0%

Bob sabia que a taxa de crescimento real deveria ser 25%, mas o código exibiu 0%. O motivo: a divisão de Int trunca os decimais — 50.000 / 200.000 é igual a 0 na aritmética inteira, e multiplicar por 100 ainda dá 0.

(2) A Solução: Usando Double para Cálculos Precisos

Mudar os dados para Double preserva os decimais durante a divisão:

let currentRevenue = 250_000.0
let previousRevenue = 200_000.0
let growthRate = (currentRevenue - previousRevenue) / previousRevenue * 100
print("Growth rate: \(growthRate)%")

Saída:

TEXT 📖 Somente leitura

📋 Copy

Growth rate: 25.0%

Problema resolvido instantaneamente. Bob então auditou 12 meses de relatórios e encontrou mais 4 instâncias de perda de precisão por divisão de Int.

(3) O Resultado: Precisão dos Relatórios Após Usar os Operadores Corretos

3. Operadores Aritméticos e de Atribuição

Operadores aritméticos realizam cálculos matemáticos; operadores de atribuição armazenam valores em variáveis. Eles são os operadores mais usados no Swift.

graph LR
    A[Operadores] --> B["Aritméticos: + - * / %"]
    A --> C["Atribuição: = += -= *= /="]
    B --> D[Cálculos Numéricos]
    C --> E[Atualizar Valores de Variáveis]

graph LR
    A[Operadores] --> B["Aritméticos: + - * / %"]
    A --> C["Atribuição: = += -= *= /="]
    B --> D[Cálculos Numéricos]
    C --> E[Atualizar Valores de Variáveis]

(1) Operadores Aritméticos

let a = 15
let b = 4
let sum = a + b      // 19
let diff = a - b     // 11
let prod = a * b     // 60
let quot = a / b     // 3 (Int division truncates decimals)
let rem = a % b      // 3 (15 / 4 = 3 remainder 3)

(2) Operadores de Atribuição Compostos

Os operadores de atribuição composta combinam aritmética com atribuição de forma mais concisa:

var score = 10
score += 5     // Equivalent to score = score + 5 -> 15
score -= 3     // Equivalent to score = score - 3 -> 12
score *= 2     // Equivalent to score = score * 2 -> 24
score /= 4     // Equivalent to score = score / 4 -> 6

▶ Exemplo: Rastreador de Despesas Mensais

// ============================================
// Track monthly expense totals
// Demonstrates arithmetic and compound assignment operators
// ============================================
var monthlyExpenses = 0.0
let rent = 1200.00
let groceries = 450.50
let transportation = 85.00
let entertainment = 200.00
monthlyExpenses += rent
monthlyExpenses += groceries
monthlyExpenses += transportation
monthlyExpenses += entertainment
let annualExpenses = monthlyExpenses * 12
let weeklyAverage = monthlyExpenses / 4.33
print("Monthly total: $\(monthlyExpenses)")
print("Annual total: $\(annualExpenses)")
print("Weekly average: $\(String(format: "%.2f", weeklyAverage))")

Saída:

TEXT 📖 Somente leitura

📋 Copy

Monthly total: $1935.5
Annual total: $23226.0
Weekly average: $447.23

4. Operadores de Comparação e Lógicos

Os operadores de comparação comparam dois valores e retornam um resultado Bool; os operadores lógicos combinam múltiplas condições booleanas.

graph TB
    A[Operadores de Comparação] --> B["== Igual a"]
    A --> C["!= Diferente de"]
    A --> D["> Maior que"]
    A --> E["< Menor que"]
    A --> F[">= Maior ou igual a"]
    A --> G["<= Menor ou igual a"]
    B --> H[Retorna Bool]
    C --> H
    D --> H

graph TB
    A[Operadores de Comparação] --> B["== Igual a"]
    A --> C["!= Diferente de"]
    A --> D["> Maior que"]
    A --> E["< Menor que"]
    A --> F[">= Maior ou igual a"]
    A --> G["<= Menor ou igual a"]
    B --> H[Retorna Bool]
    C --> H
    D --> H

(1) Operadores de Comparação

let age = 18
let isAdult = age >= 18     // true
let canDrive = age >= 16    // true
let isSenior = age > 65     // false
let userName = "Alice"
let isAdmin = userName == "Admin"  // false

(2) Operadores Lógicos

let hasTicket = true
let isVip = false
let canEnter = hasTicket && isVip   // false
let canAccess = hasTicket || isVip  // true
let isNotVip = !isVip               // true

▶ Exemplo: Verificação de Permissão de Usuário

// ============================================
// Check if a user has access to the admin panel
// Demonstrates comparison and logical operators
// ============================================
let userAge = 22
let hasVerifiedEmail = true
let isBanned = false
let isAdmin = false
let isAdult = userAge >= 18
let canAccessSystem = isAdult && hasVerifiedEmail && !isBanned
let hasAdminAccess = isAdmin
let finalAccess = canAccessSystem || hasAdminAccess
print("Adult: \(isAdult)")
print("Email verified: \(hasVerifiedEmail)")
print("Not banned: \(!isBanned)")
print("Final access: \(finalAccess)")

Saída:

TEXT 📖 Somente leitura

📋 Copy

Adult: true
Email verified: true
Not banned: true
Final access: true

5. O Operador Ternário e Conversão de Tipo

O operador ternário é uma alternativa concisa ao if-else; a conversão de tipo numérico permite que diferentes tipos trabalhem juntos.

(1) O Operador Condicional Ternário

Sintaxe: condicao ? valorA : valorB — retorna valorA se a condição for verdadeira, caso contrário retorna valorB:

let score = 85
let grade = score >= 60 ? "Pass" : "Fail"
print(grade)  // Pass

var result: String
if score >= 60 {
    result = "Pass"
} else {
    result = "Fail"
}
let result2 = score >= 60 ? "Pass" : "Fail"

(2) Conversão de Tipo Numérico

Int e Double exigem conversão explícita entre eles:

let x = 10       // Int
let y = 3.5      // Double
let result1 = Double(x) + y  // 13.5
let result2 = x + Int(y)     // 13 (y truncated to 3)

▶ Exemplo: Calculadora de Desconto

// ============================================
// Calculate discount based on purchase amount
// Demonstrates the ternary operator and type conversion
// ============================================
let purchaseAmount = 120.0
let itemCount = 3
let discountRate: Double = purchaseAmount >= 100 ? 0.9 : 1.0
let finalAmount = purchaseAmount * discountRate
let averagePrice = finalAmount / Double(itemCount)
print("Purchase amount: $\(purchaseAmount)")
print("Discount: \(Int((1 - discountRate) * 100))%")
print("Final amount: $\(finalAmount)")
print("Item count: \(itemCount)")
print("Average price per item: $\(String(format: "%.2f", averagePrice))")
let freeShipping = finalAmount >= 100 ? "Free Shipping" : "Shipping Fee"
print("Shipping: \(freeShipping)")

Saída:

TEXT 📖 Somente leitura

📋 Copy

Purchase amount: $120.0
Discount: 10%
Final amount: $108.0
Item count: 3
Average price per item: $36.00
Shipping: Free Shipping

6. Exemplo Completo: Analisador de Orçamento Mensal

// ============================================
// Monthly budget analysis tool
// Demonstrates arithmetic, comparison, logical, and ternary operators
// ============================================
import Foundation
// 1. Income and expense data
let salary = 5200.0
let rent = 1400.0
let food = 600.0
let transport = 120.0
let utilities = 200.0
let entertainment = 300.0
// 2. Calculate using arithmetic and compound assignment
var totalExpenses = 0.0
totalExpenses += rent
totalExpenses += food
totalExpenses += transport
totalExpenses += utilities
totalExpenses += entertainment
let savings = salary - totalExpenses
let savingsRate = savings / salary * 100
// 3. Use comparison and ternary to assess financial health
let isHealthy = savingsRate >= 20
let advice = isHealthy ? "Healthy" : "Needs Improvement"
// 4. Logical check: any single category over budget?
let rentTooHigh = rent > salary * 0.3
let foodTooHigh = food > salary * 0.15
let needsAdjustment = rentTooHigh || foodTooHigh
print("=== Monthly Budget ===")
print("Income: $\(salary)")
print("Expenses: $\(totalExpenses)")
print("Savings: $\(String(format: "%.2f", savings))")
print("Savings Rate: \(Int(savingsRate))%")
print("Status: \(advice)")
print("Needs Adjustment: \(needsAdjustment)")
// 5. Type conversion example
let categoryCount = 5
let avgPerCategory = totalExpenses / Double(categoryCount)
print("Categories: \(categoryCount), Avg: $\(String(format: "%.2f", avgPerCategory))")

Saída:

TEXT 📖 Somente leitura

📋 Copy

=== Monthly Budget ===
Income: $5200.0
Expenses: $2620.0
Savings: $2580.0
Savings Rate: 49%
Status: Healthy
Needs Adjustment: false
Categories: 5, Avg: $524.00

❓ Perguntas Frequentes

P: Como obter resultados decimais na divisão de Int? R: Converta pelo menos um operando para Double. Por exemplo, Double(10) / 3 resulta em 3.3333. Ou declare como 10.0 / 3 desde o início. P: O operador % pode ser usado com Double? R: Não. O % do Swift só funciona com inteiros. Para resto de ponto flutuante, use o método truncatingRemainder(dividingBy:). P: && e || usam avaliação de curto-circuito? R: Sim. && não avalia o lado direito se o esquerdo for falso; || não avalia o lado direito se o esquerdo for verdadeiro. Use isso com sabedoria para melhorar a eficiência. P: Os operadores de atribuição composta retornam um valor? R: Não. x += 5 é uma instrução, não uma expressão, e não pode ser usado em atribuições ou comparações. Isso difere do C.

📖 Resumo

• Operadores aritméticos: + - * / %. A divisão de Int trunca os decimais.
• Atribuição composta: += -= *= /= para atualizações concisas de variáveis.
• Operadores de comparação: == != > < >= <=. Todos retornam Bool.
• Operadores lógicos: && (E), || (OU), ! (NÃO). Suportam avaliação de curto-circuito.
• Operador ternário: condicao ? valorA : valorB para escolhas de um-ou-outro em uma linha.
• Conversão de tipo numérico: Double() ou Int() para garantir compatibilidade de tipo.

📝 Exercícios

1. Iniciante: Use operadores aritméticos para calcular a área e o perímetro de um retângulo com comprimento 12.5 e largura 8.3. Exiba os resultados.
2. Intermediário: Escreva um programa para determinar se um ano é bissexto. Regra: divisível por 4 mas não por 100, ou divisível por 400. Use operadores lógicos para combinar as condições.
3. Desafio: Escreva um calculador de conta de luz. A tarifa base é R$0,12/kWh. Para consumo mensal acima de 300kWh, o excedente é cobrado a R$0,15/kWh. Use o operador ternário e operadores aritméticos para calcular o total da conta.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós