Swift: o que é, sintaxe e conceitos-chave da linguagem

O que é Swift?

Swift é uma linguagem de programação multiparadigma desenvolvida pela Apple para iOS, macOS, watchOS, tvOS e visionOS. Os principais objetivos da linguagem são: segurança, velocidade e expressividade sintática. Swift usa o compilador LLVM e gera código de máquina otimizado, comparável em desempenho ao C++.

Desde seu lançamento em 2014, Swift passou por 6 versões principais. O Swift 6 (2024) introduziu um modelo completo de segurança contra data races através do controle rigoroso do isolamento de código concorrente. De acordo com o GitHub Octoverse 2025, Swift está entre as 10 linguagens com maior crescimento da comunidade, superando Rust e Kotlin em velocidade de adoção nas plataformas Apple.

Swift é código aberto e multiplataforma — o código-fonte é publicado no GitHub (Swift Open Source). Além das plataformas Apple, Swift é usado em Linux e Windows para desenvolvimento server-side (Vapor, Hummingbird), embora seu domínio principal permaneça o desenvolvimento móvel e desktop no ecossistema Apple.

Por que Swift substituiu Objective-C

As principais razões para a transição: Swift elimina classes inteiras de erros possíveis em Objective-C. Type safety impede incompatibilidades de tipo em tempo de compilação. Optionals eliminam desreferências nil. ARC está integrado desde o primeiro dia, ao contrário de MRC/ARC em Objective-C. A sintaxe do Swift é mais curta e legível — estudos mostram uma redução de 30-40% no volume de código em comparação com Objective-C para tarefas equivalentes.

Sintaxe e construções básicas

A sintaxe básica do Swift combina construções familiares semelhantes a C com elementos de linguagens funcionais. As variáveis são declaradas com var, as constantes com let. O compilador usa inferência de tipos, portanto a anotação explícita de tipo é necessária apenas em casos ambíguos.

import Foundation

// Constantes e variáveis
let name = "Swift"
var version = 6.0
var count: Int = 42

// Funções com parâmetros padrão
func greet(person: String, greeting: String = "Hello") -> String {
    return "\(greeting), \(person)!"
}

// Guard-let para saída antecipada
func parse(input: String?) -> Int {
    guard let value = input, let number = Int(value) else {
        return 0
    }
    return number
}

Switch e pattern matching em Swift são mais poderosos que em C e Kotlin. O Switch suporta correspondência com tuplas, intervalos, condições where e vinculação de valores. O compilador verifica a cobertura exaustiva de todos os casos — omitir default não é um erro se todos os valores possíveis estiverem cobertos.

let point = (x: 3, y: -1)

switch point {
case (0, 0):
    print("Origem")
case let (x, y) where x == y:
    print("X é igual a Y")
case let (x, y) where abs(y) > x:
    print("O valor absoluto de Y é maior que X")
default:
    print("Ponto (\(point.x), \(point.y))")
}

Optionals e trabalho seguro com nil

Optionals são um conceito central do Swift que resolve o problema de referências nulas ao nível do sistema de tipos. Optional é um enum com dois casos: .none (nil) e .some(Wrapped). O compilador proíbe usar um Optional sem verificação explícita, eliminando toda uma classe de erros em tempo de execução.

var optionalString: String? = "Hello"
optionalString = nil  // permitido

// Optional Binding — extração segura
if let text = optionalString {
    print("Texto: \(text)")
} else {
    print("Valor ausente")
}

// Optional Chaining — acesso seguro a propriedades
let length = optionalString?.count ?? 0

// Operador nil-coalescing
let greeting = optionalString ?? "Default"

Optional Chaining com o operador ?. permite chamar métodos e acessar propriedades de um valor opcional de forma segura. Se a cadeia for interrompida por nil, o resultado de toda a expressão é nil. Nil-coalescing (??) fornece um valor padrão e é amplamente usado em código de UI para exibir texto placeholder.

Protocolos e extensões

Protocolos em Swift definem um contrato — um conjunto de propriedades e métodos. Ao contrário das interfaces Java, os protocolos Swift podem ter implementações padrão via protocol extensions. Esta é a base da Programação Orientada a Protocolos, a abordagem recomendada pela Apple em vez da herança de classes.

protocol NamedEntity {
    var name: String { get }
    func description() -> String
}

// Implementação padrão via extension
extension NamedEntity {
    func description() -> String {
        return "Entity: \(name)"
    }
}

// Conformidade via extension
extension String: NamedEntity {
    var name: String { return self }
}

Protocol Extensions permitem adicionar métodos a um protocolo sem modificar cada tipo conforme. Isso é especialmente útil para adicionar utilitários comuns: map, filter, reduce para Sequence, ou Codable para serialização JSON. A Apple construiu muitos frameworks (SwiftUI, Combine) sobre protocolos com extensões.

Closures e cadeias funcionais

Closures em Swift são funções anônimas que capturam variáveis do contexto externo. Sintaticamente, closures se assemelham a lambdas em Kotlin, mas com uma sintaxe mais flexível: trailing closure, nomes de argumento abreviados ($0, $1) e autoclosures.

// Closure com captura de contexto
let numbers = [5, 3, 8, 1, 9]

// Trailing closure syntax
let sorted = numbers.sorted { $0 < $1 }

// Cadeia funcional
let result = numbers
    .filter { $0 > 3 }
    .map { $0 * 2 }
    .reduce(0, +)

// Closure como parâmetro de função
func performAsync(completion: @escaping (Result<Data, Error>) -> Void) { }

Closures @escaping são usados quando o closure é executado após o retorno da função — tipicamente para requisições de rede e operações assíncronas. @autoclosure envolve automaticamente uma expressão em um closure, usado em assert e lógica de curto-circuito.

Estruturas e classes: comparação

A escolha entre struct e class é uma das primeiras decisões ao projetar um modelo Swift. A Apple recomenda usar struct por padrão (tipo valor) e mudar para class (tipo referência) apenas quando for necessária herança ou identidade por referência.

Tipos valor (struct) são mais seguros em ambientes multithread — cada thread obtém uma cópia independente. Tipos referência (class) são necessários para trabalhar com UIKit (UIView, UIViewController), onde é necessária identidade por referência e herança de classes do sistema.

Gerenciamento de memória ARC

ARC (Automatic Reference Counting) é o sistema de gerenciamento de memória do Swift para tipos referência. O compilador insere chamadas retain/release em tempo de execução, rastreando o número de referências fortes a um objeto. Quando o contador chega a zero, o objeto é imediatamente liberado.

O principal problema do ARC são os retain cycles (ciclos de retenção). Quando dois objetos mantêm referências fortes entre si, a memória nunca é liberada. A solução são referências weak (tornam-se nil automaticamente ao serem liberadas) e referências unowned (garantem que o objeto está vivo).

class ProfileViewController: UIViewController {
    var onLogout: (() -> Void)?
    
    func setupHandler() {
        // [weak self] previne retain cycle
        onLogout = { [weak self] in
            guard let self else { return }
            self.dismiss(animated: true)
        }
    }
}

Para prevenir retain cycles em closures, use [weak self] com guard let self = self else { return }. Esta regra é especialmente importante no UIKit, onde o ViewController mantém referências fortes às suas propriedades e os closures dentro dessas propriedades referenciam o ViewController.