Este guia é um material de apoio para quem está começando na linguagem Swift, especialmente para estudantes que já possuem uma base em lógica de programação.

Swift é uma linguagem moderna, estaticamente tipada, criada pela Apple em 2014 para substituir o Objective-C como linguagem principal do ecossistema iOS/macOS. É o par natural de Kotlin — a mesma relação de “linguagem moderna que substitui a linguagem legada da plataforma”, mas do lado Apple em vez de Android/Google.

🔹 Por que Swift em vez de Objective-C?

Swift foi desenhado do zero para corrigir pontos de atrito históricos do Objective-C:

  • Sintaxe moderna e concisa: sem a herança de sintaxe do C/Smalltalk do Objective-C ([objeto mensagem:parametro]), Swift usa notação de ponto convencional (objeto.metodo(parametro)).
  • Optionals no lugar de ponteiros nulos: o sistema de tipos distingue String (nunca nulo) de String? (pode ser nulo) — o mesmo tipo de proteção contra null/nil que Kotlin oferece sobre Java.
  • Interoperabilidade com Objective-C: projetos podem misturar os dois na mesma base de código, o que permitiu uma migração gradual em vez de uma reescrita completa — é por isso que Objective-C ainda aparece em código legado de apps antigos.
  • Type inference e segurança: menos boilerplate que Objective-C, com verificação de tipos em tempo de compilação.

🛠️ Instalação e Configuração do Ambiente

Desenvolver em Swift na prática exige um Mac com Xcode (a IDE oficial da Apple, que inclui o compilador Swift, simulador de iOS e ferramentas de build).

Xcode

Baixe pela Mac App Store. Após instalar, verifique o compilador no terminal:

swift --version

🚀 Seu Primeiro Programa em Swift

Fora do Xcode, é possível rodar Swift direto no terminal (útil para aprender a linguagem sem precisar montar um projeto de app completo):

// ola.swift
print("Ola, Universo Swift!")

swift ola.swift

O resultado será:

Ola, Universo Swift!

Análise do Código

  • print() exibe texto no console, com quebra de linha automática — mesmo nome usado em Kotlin.
  • Não há necessidade de main() explícito em um script de arquivo único; em um projeto de app real, o ponto de entrada é a App struct (@main).

📊 Tipos de Dados e Variáveis

Swift também tem inferência de tipos, mas o tipo existe e é checado em tempo de compilação.

let nome: String = "Ana Souza"
let idade: Int = 25
let salario: Double = 6200.75
let estudante: Bool = true

let declara uma constante (não pode ser reatribuída); var declara uma variável mutável — a mesma distinção que val/var em Kotlin:

var contador = 0
contador += 1

Optionals

var nome: String = "Ana"
// nome = nil   // ERRO de compilação: String não aceita nil

var apelido: String? = nil   // "?" permite nil explicitamente

if let apelidoDesempacotado = apelido {
    print("Apelido: \(apelidoDesempacotado)")
} else {
    print("Sem apelido")
}

Se apelido pode ser nil, o compilador obriga você a “desempacotar” o optional antes de usar o valor — com if let, guard let ou ! (force unwrap, arriscado). É a mesma ideia dos String? de Kotlin, com sintaxe própria.

🔢 Operadores

Aritméticos

Operador Significado
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Resto da divisão

Comparativos

Operador Significado
== Igual (compara valor)
!= Diferente
>, <, >=, <= Comparação numérica

Lógicos

Operador Significado
&& E (AND)
|| OU (OR)
! NÃO (NOT)

📤 Saída de Dados

let idade = 25
let salario = 6200.75
let nome = "Ana Souza"

print("IDADE = \(idade)")
print("SALARIO = \(salario)")
print("NOME = \(nome)")

\(expressao) dentro de uma string faz interpolação direta — a mesma ideia do ${...} do Kotlin, mas com barra invertida em vez de cifrão.

📥 Entrada de Dados

print("Digite seu nome: ", terminator: "")
if let nome = readLine() {
    print("Ola, \(nome)!")
}

readLine() devolve String? (pode ser nil se a entrada for fechada) — precisa ser desempacotado com if let, igual ao ?: que trata o null de readLine() em Kotlin.

🔀 Estrutura Condicional

func saudacaoPorHora(_ hora: Int) -> String {
    if hora < 6 {
        return "Boa madrugada!"
    } else if hora < 12 {
        return "Bom dia!"
    } else if hora < 18 {
        return "Boa tarde!"
    } else {
        return "Boa noite!"
    }
}

switch (mais parecido com o when do Kotlin do que com o switch de C)

func saudacaoPorHora(_ hora: Int) -> String {
    switch hora {
    case ..<6:
        return "Boa madrugada!"
    case 6..<12:
        return "Bom dia!"
    case 12..<18:
        return "Boa tarde!"
    default:
        return "Boa noite!"
    }
}

Diferente do switch de C/Java, o switch de Swift não tem fall-through implícito (não precisa de break) e aceita ranges (6..<12) diretamente nos case — a mesma expressividade do when de Kotlin.

🔁 Estruturas de Repetição

// for-in com range
for i in 1...10 {
    print(i)
}

// while
var contador = 0
while contador < 5 {
    print(contador)
    contador += 1
}

1...10 é um range fechado (inclui o 10); 1..<10 é um range aberto no limite superior — a mesma ideia do 1..10 de Kotlin, com sintaxe de três/dois pontos.

📏 Arrays e Dictionaries

let numeros = [10, 20, 30, 40]

print(numeros[0])
print(numeros.count)

let dobrados = numeros.map { $0 * 2 } let pares = numeros.filter {$0 % 2 == 0 }

$0 é o nome implícito do primeiro parâmetro de uma closure — o equivalente Swift do it de Kotlin em lambdas.

🧩 Funções

func somar(a: Int, b: Int) -> Int {
    return a + b
}

somar(a: 2, b: 3)

Por padrão, os nomes dos parâmetros fazem parte da chamada (somar(a: 2, b: 3), não somar(2, 3)) — um detalhe de legibilidade sem equivalente direto em Kotlin. Para omitir o rótulo, usa-se _:

func somar(_ a: Int, _ b: Int) -> Int {
    return a + b
}

somar(2, 3)

🍎 Swift no iOS (SwiftUI)

Assim como Kotlin tem o Jetpack Compose no Android, Swift tem o SwiftUI — um toolkit de UI declarativa:

struct GreetingScreen: View {
    @State private var horario: String = ""
    @State private var resultado: String = ""

    var body: some View {
        VStack {
            Text("Digite uma hora do dia (formato HH:MM):")
            TextField("HH:MM", text: $horario)
            Button("Enviar") {
                resultado = saudacaoPorHora(horario)
            }
            Text(resultado)
        }
    }
}

@State marca uma propriedade como estado reativo — quando ela muda, o SwiftUI recalcula automaticamente a body — o mesmo modelo mental do remember { mutableStateOf(...) } do Jetpack Compose, do React e do Vue.

🧓 E o Objective-C?

Swift interopera 100% com Objective-C, a linguagem que ela substituiu — projetos podem misturar os dois na mesma base de código, o que permitiu à indústria migrar aos poucos em vez de reescrever tudo de uma vez. Se você vai mexer em código iOS legado (sintaxe de mensagens [objeto metodo:parametro], arquivos .h/.m, sem optionals), veja a seção sobre Objective-C mais acima neste mesmo capítulo.

⚠️ Erros Comuns de Iniciantes

Fazer force unwrap sem necessidade

let apelido: String? = nil
print(apelido!) // ERRO em tempo de execução: crash

! força o desempacotamento de um optional assumindo que ele nunca é nil — se essa suposição estiver errada, o app crasha em produção. Prefira if let/guard let sempre que houver dúvida.

Confundir let com var

Igual ao val/var de Kotlin: tentar reatribuir uma constante let é erro de compilação — iniciantes vindos de linguagens sem essa distinção (como JavaScript com var) esquecem disso com frequência.

Esquecer os rótulos de parâmetro na chamada

func somar(a: Int, b: Int) -> Int { a + b }

somar(2, 3)        // ERRO: faltam os rótulos "a:" e "b:"
somar(a: 2, b: 3)   // Correto

🎓 Conclusão

Swift ocupa no ecossistema Apple o mesmo papel que Kotlin ocupa no Android: uma linguagem moderna, seguramente tipada e com optionals no lugar de ponteiros nulos, que interopera com a linguagem legada da plataforma (Objective-C) para permitir migração gradual. Domine os fundamentos daqui e o paralelo mais próximo no curso é o tópico de Kotlin — compare os dois lado a lado para ver como plataformas concorrentes chegaram a soluções muito parecidas para os mesmos problemas.