Swift: Variáveis e Constantes do Swift

As variáveis são como caixas etiquetadas onde você pode trocar o conteúdo a qualquer momento; as constantes são como caixas seladas que não podem ser alteradas. Esta lição aborda as duas maneiras principais de armazenar dados em Swift.

1. O Que Você Vai Aprender

• A diferença entre var (variáveis) e let (constantes)
• Como a inferência de tipo do Swift identifica automaticamente os tipos de dados
• Os quatro tipos de dados básicos: Int, Double, String, Bool
• Como o mecanismo de segurança de tipo previne erros de código
• Converter valores entre diferentes tipos

2. Uma História Real: Uma Analista de Dados de E-Commerce

(1) O Problema: Misturar Números com Texto Causou uma Falha

Alice é uma analista de dados de e-commerce que processa mais de 50.000 registros de pedidos diariamente. Ela escreveu um código para acompanhar as mudanças mensais de vendas de um produto:

var orderCount = "8500"
// Next month, orders grew by 1200
orderCount = orderCount + 1200  // Compilation error!

O Swift não permite misturar texto e números. O código de Alice não compilava. Ela levou 30 minutos para encontrar a causa raiz — as aspas em "8500" fizeram o Swift tratá-lo como texto (String) em vez de número (Int).

(2) A Solução: Declarar os Tipos de Variáveis Corretamente

Basta remover as aspas na declaração que o Swift infere corretamente que 8500 é um inteiro:

// Correct data type definitions
var orderCount = 8500          // Int
var productName = "Headphones" // String
var unitPrice = 49.99          // Double
orderCount = orderCount + 1200
let totalRevenue = Double(orderCount) * unitPrice
print("Product: \(productName)")
print("Monthly sales: \(orderCount), Revenue: $\(totalRevenue)")

Saída:

TEXT 📖 Somente leitura

📋 Copy

Product: Headphones
Monthly sales: 9700, Revenue: $485003.0

(3) O Resultado: Eficiência de Codificação Após Entender os Tipos

3. Variáveis e Constantes

O Swift usa var para variáveis (valores podem mudar) e let para constantes (valores são fixos após a atribuição). A escolha depende se os dados precisam mudar.

graph TB
    A[Armazenamento de Dados] --> B["var Variável"]
    A --> C["let Constante"]
    B --> D[Valor pode ser modificado]
    B --> E["var idade = 25"]
    B --> F["idade = 26 ✅"]
    C --> G[Valor não pode ser modificado]
    C --> H["let nome = \"Alice\""]
    C --> I["nome = \"Bob\" ❌"]

graph TB
    A[Armazenamento de Dados] --> B["var Variável"]
    A --> C["let Constante"]
    B --> D[Valor pode ser modificado]
    B --> E["var idade = 25"]
    B --> F["idade = 26 ✅"]
    C --> G[Valor não pode ser modificado]
    C --> H["let nome = \"Alice\""]
    C --> I["nome = \"Bob\" ❌"]

(1) Variáveis — Declaradas com var

Variáveis armazenam dados que mudam durante a execução do programa:

// Variable values can be modified at any time
var score = 0
score = 85           // Update value
score = score + 10   // Recalculate based on current value

(2) Constantes — Declaradas com let

Uma vez atribuído, o valor de uma constante não pode ser alterado. Usar let previne bugs causados por modificação acidental:

// Constants cannot be modified after assignment
let maxLoginAttempts = 5
// maxLoginAttempts = 6  // ❌ Compilation error
let pi = 3.14159
let appName = "MyApp"

▶ Exemplo: Gerenciando Dados do Carrinho de Compras

// ============================================
// Use variables for cart quantity, constants for product info
// ============================================
// Constants: Fixed information
let productName = "Wireless Headphones"
let unitPrice = 79.99
// Variable: Changing data
var quantity = 1
print("Product: \(productName)")
print("Unit price: $\(unitPrice)")
print("Current quantity: \(quantity)")
// User increased the purchase quantity
quantity = 3
let total = unitPrice * Double(quantity)
print("Buying \(quantity) items, Total: $\(total)")

Saída:

TEXT 📖 Somente leitura

📋 Copy

Product: Wireless Headphones
Unit price: $79.99
Current quantity: 1
Buying 3 items, Total: $239.97

4. Tipos de Dados Básicos

O Swift fornece quatro tipos de dados básicos comumente usados, cada um armazenando uma forma específica de dados. Uma vez que o tipo de uma variável ou constante é determinado, ele não pode armazenar dados de um tipo diferente.

graph TB
    A[Tipos de Dados Básicos] --> B["Int Inteiro"]
    A --> C["Double Ponto Flutuante"]
    A --> D["String Texto"]
    A --> E["Bool Booleano"]
    B --> F["42, -10, 0"]
    C --> G["3.14, -0.5"]
    D --> H["\"Olá\""]
    E --> I["true / false"]

graph TB
    A[Tipos de Dados Básicos] --> B["Int Inteiro"]
    A --> C["Double Ponto Flutuante"]
    A --> D["String Texto"]
    A --> E["Bool Booleano"]
    B --> F["42, -10, 0"]
    C --> G["3.14, -0.5"]
    D --> H["\"Olá\""]
    E --> I["true / false"]

(1) Int — Inteiros

Int armazena números inteiros. Em dispositivos de 64 bits, o intervalo é aproximadamente ±9,2 × 10^18:

let year = 2026
var count = -100
let population: Int = 8_000_000_000  // Underscores improve readability

(2) Double — Números de Ponto Flutuante

Double armazena números com casas decimais, com pelo menos 15 dígitos decimais de precisão:

let temperature = 36.5
var price = 19.99
let taxRate = 0.08

(3) String — Texto

String armazena dados textuais, delimitados por aspas duplas:

let userName = "Alice"
var message = "Welcome to Swift"
let empty = ""  // Empty string

(4) Bool — Booleano

Bool tem apenas dois valores, true e false, usados para lógica condicional:

let isLoggedIn = false
var isAvailable = true
let isGreater = 10 > 5  // Comparison automatically produces true

▶ Exemplo: Verificação de Tipo de Informações do Usuário

// ============================================
// Storing user information with different types
// ============================================
let userName = "Bob"        // String
var age = 28                // Int
let height = 1.85           // Double
var isPremiumMember = false // Bool
print("Name: \(userName)")
print("Age: \(age)")
print("Height: \(height) m")
print("Member: \(isPremiumMember)")
// Type safety — the following line will not compile
// age = "twenty-eight"  // ❌ Cannot assign String to Int

Saída:

TEXT 📖 Somente leitura

📋 Copy

Name: Bob
Age: 28
Height: 1.85 m
Member: false

5. Anotações de Tipo e Conversão de Tipo

O Swift é uma linguagem segura em relação a tipos — o tipo de cada variável e constante deve ser determinado em tempo de compilação. Você pode deixar o Swift inferir o tipo ou especificá-lo manualmente.

(1) Anotações de Tipo Explícitas

Adicione dois pontos e o nome do tipo após o nome da variável ou constante para especificar explicitamente o tipo:

let name: String = "Charlie"
var age: Int = 25
var price: Double = 29.99
let isActive: Bool = true

(2) Conversão de Tipo

Tipos diferentes não podem ser operados ou atribuídos diretamente — é necessária conversão explícita:

let apples = 3
let pricePerApple = 0.99
// let total = apples * pricePerApple     // ❌ Int and Double cannot multiply directly
let total = Double(apples) * pricePerApple  // ✅ Convert Int to Double

▶ Exemplo: Cálculo do Total do Pedido

// ============================================
// Calculate order total, demonstrating type conversion
// ============================================
import Foundation
let itemCount = 5            // Int
let unitPrice = 12.99        // Double
let taxPercent = 0.08        // Double
// Int must be converted to Double for arithmetic
let subtotal = Double(itemCount) * unitPrice
let taxAmount = subtotal * taxPercent
let total = subtotal + taxAmount
print("Item count: \(itemCount)")
print("Unit price: $\(unitPrice)")
print("Subtotal: $\(subtotal)")
print("Tax (8%): $\(taxAmount)")
print("Total: $\(total)")
// Convert Double to String for text concatenation
let receipt = "Total: $" + String(format: "%.2f", total)
print(receipt)

Saída:

TEXT 📖 Somente leitura

📋 Copy

Item count: 5
Unit price: $12.99
Subtotal: $64.95
Tax (8%): $5.196
Total: $70.146
Total: $70.15

6. Exemplo Completo: Resumo de Estatísticas de Pedidos

// ============================================
// E-commerce order statistics summary
// Demonstrates variables, constants, data types, type conversion
// ============================================
import Foundation
// 1. Constants: Store info and fixed configuration
let storeName = "Swift Gear Shop"
let taxRate = 0.07
// 2. Variables: Mutable order data
var orderCount = 0
var totalRevenue = 0.0
// 3. Process first batch of orders
let price1 = 49.99
let qty1 = 3
orderCount += qty1
let subtotal1 = Double(qty1) * price1
totalRevenue += subtotal1
// 4. Process second batch of orders
let price2 = 129.00
let qty2 = 1
orderCount += qty2
let subtotal2 = Double(qty2) * price2
totalRevenue += subtotal2
// 5. Output statistics report
print("Store: \(storeName)")
print("=== Sales Statistics ===")
print("Items sold: \(orderCount)")
print("Total revenue: $\(totalRevenue)")
print("Estimated tax: $\(totalRevenue * taxRate)")
print("Net revenue: $\(totalRevenue * (1 - taxRate))")
let summary = "Processed " + String(orderCount) + " items today"
print(summary)

Saída:

TEXT 📖 Somente leitura

📋 Copy

Store: Swift Gear Shop
=== Sales Statistics ===
Items sold: 4
Total revenue: $278.97
Estimated tax: $19.5279
Net revenue: $259.4421
Processed 4 items today

❓ Perguntas Frequentes

P: Existe diferença de desempenho entre let e var? R: O compilador pode aplicar mais otimizações às constantes let (como substituição inline), dando a elas uma leve vantagem de desempenho sobre var. No entanto, no desenvolvimento diário, a diferença é insignificante — priorize a correção semântica. P: Por que String e Int não podem ser concatenados diretamente? R: Porque String e Int são tipos de dados completamente diferentes. O Swift é uma linguagem segura em relação a tipos e não permite conversão implícita de tipo. Use interpolação de string \(valor) ou a função String() para conversão explícita. P: Quando devo obrigatoriamente escrever uma anotação de tipo? R: Três casos: sem valor inicial na declaração, o valor inicial pode ser ambíguo ou você quer ser explícito sobre o tipo. Por exemplo, var pontuacao: Int para declarar primeiro e atribuir depois, ou let valor: Double = 5 para forçar 5 a ser Double em vez de Int. P: Qual é o valor máximo de Int? O que acontece em caso de overflow? R: Em dispositivos de 64 bits, o intervalo de Int é aproximadamente ±9,2 × 10^18. O overflow no modo de depuração causará uma falha com erro, mas o Swift também fornece operadores de overflow como &+ para tratar casos especiais com segurança.

📖 Resumo

• Use var para variáveis (valores podem mudar) e let para constantes (valores não podem mudar)
• O Swift determina os tipos por meio de inferência de tipo, então você nem sempre precisa de anotações de tipo
• Quatro tipos de dados básicos: Int (números inteiros), Double (decimais), String (texto), Bool (true/false)
• O Swift é uma linguagem segura em relação a tipos — você não pode misturar ou converter implicitamente entre tipos diferentes
• A conversão de tipo usa a sintaxe Tipo(valor), por exemplo, Double(3) produz 3.0
• Prefira let, use var apenas quando o valor precisar mudar

📝 Exercícios

1. Iniciante: Declare uma constante let cidade = "Nova York" e uma variável var populacao = 8_400_000, depois use print para exibir "Nova York tem 8400000 pessoas".
2. Intermediário: Defina uma variável Double armazenando uma temperatura em Celsius, converta-a para Fahrenheit (fórmula: °F = °C × 9/5 + 32) e exiba o resultado em ambas as unidades.
3. Desafio: Escreva um programa conversor de moedas. Use uma constante para armazenar a taxa de câmbio (1 USD = 0,92 EUR), uma variável para armazenar um valor em dólar, depois calcule e exiba o valor correspondente em euro. Deve usar pelo menos três tipos: Int, Double e String.

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