Swift: Desenvolvimento Apple Moderno

Swift é uma linguagem de programação poderosa e intuitiva criada pela Apple em 2014. Projetada para ser segura, rápida e expressiva, Swift é a linguagem principal para desenvolvimento iOS, macOS, watchOS, tvOS e até aplicações server-side.

Por que Swift? Swift combina performance próxima de C com sintaxe moderna e segura. Com SwiftUI, criar interfaces nativas nunca foi tão simples e declarativo.

Características Distintivas

1. Type Safety - Sistema de tipos rigoroso que previne erros
2. Optionals - Tratamento elegante de valores nulos
3. Protocol-Oriented - Composição sobre herança
4. Value Types - Structs e enums como cidadãos de primeira classe
5. SwiftUI - Framework declarativo para interfaces
6. Concurrency - async/await e actors nativos

Fundamentos

Tipos e Variáveis

// Constantes e variáveis
let nome: String = "Maria"  // Constante (imutável)
var idade: Int = 25         // Variável (mutável)
let altura = 1.68           // Inferência de tipo (Double)
let ativo = true            // Bool

// Optionals - valores que podem ser nil
var email: String? = nil
email = "[email protected]"

// Optional binding
if let emailSeguro = email {
    print("Email: \(emailSeguro)")
}

// Guard para early exit
func processarEmail(_ email: String?) {
    guard let email = email else {
        print("Email inválido")
        return
    }
    print("Processando: \(email)")
}

// Nil coalescing
let displayEmail = email ?? "Não informado"

// Arrays e Dicionários
var frutas: [String] = ["maçã", "banana", "laranja"]
frutas.append("uva")

var usuarios: [String: Int] = [
    "alice": 25,
    "bob": 30
]

// Sets
var tags: Set<String> = ["swift", "ios", "apple"]

Funções e Closures

// Função com parâmetros nomeados
func saudar(pessoa nome: String, com mensagem: String = "Olá") -> String {
    return "\(mensagem), \(nome)!"
}
let saudacao = saudar(pessoa: "Maria", com: "Bem-vinda")

// Múltiplos retornos com tuplas
func calcularEstatisticas(_ numeros: [Int]) -> (min: Int, max: Int, soma: Int) {
    let min = numeros.min() ?? 0
    let max = numeros.max() ?? 0
    let soma = numeros.reduce(0, +)
    return (min, max, soma)
}

// Closures
let dobrar = { (numero: Int) -> Int in
    return numero * 2
}

// Closure simplificado
let triplicar: (Int) -> Int = { $0 * 3 }

// Higher-order functions
let numeros = [1, 2, 3, 4, 5]
let dobrados = numeros.map { $0 * 2 }
let pares = numeros.filter { $0 % 2 == 0 }
let soma = numeros.reduce(0, +)

// Trailing closure
func executar(repeticoes: Int, acao: () -> Void) {
    for _ in 0..<repeticoes {
        acao()
    }
}

executar(repeticoes: 3) {
    print("Executando...")
}

Structs e Classes

// Struct (value type) - preferido em Swift
struct Usuario: Identifiable, Codable {
    let id: UUID
    var nome: String
    var email: String
    var ativo: Bool
    
    init(nome: String, email: String) {
        self.id = UUID()
        self.nome = nome
        self.email = email
        self.ativo = true
    }
    
    mutating func desativar() {
        ativo = false
    }
    
    func saudar() -> String {
        "Olá, \(nome)!"
    }
}

// Class (reference type)
class GerenciadorUsuarios: ObservableObject {
    @Published var usuarios: [Usuario] = []
    
    func adicionar(_ usuario: Usuario) {
        usuarios.append(usuario)
    }
    
    func remover(id: UUID) {
        usuarios.removeAll { $0.id == id }
    }
}

// Computed properties
struct Retangulo {
    var largura: Double
    var altura: Double
    
    var area: Double {
        largura * altura
    }
    
    var perimetro: Double {
        2 * (largura + altura)
    }
}

Enums e Pattern Matching

// Enum com valores associados
enum Resultado<T> {
    case sucesso(T)
    case erro(mensagem: String, codigo: Int)
}

// Enum com raw values
enum Status: String, CaseIterable {
    case pendente = "PENDENTE"
    case aprovado = "APROVADO"
    case rejeitado = "REJEITADO"
    
    var emoji: String {
        switch self {
        case .pendente: return "⏳"
        case .aprovado: return "✅"
        case .rejeitado: return "❌"
        }
    }
}

// Pattern matching com switch
func processar<T>(_ resultado: Resultado<T>) {
    switch resultado {
    case .sucesso(let valor):
        print("Sucesso: \(valor)")
    case .erro(let mensagem, let codigo) where codigo >= 500:
        print("Erro crítico (\(codigo)): \(mensagem)")
    case .erro(let mensagem, let codigo):
        print("Erro (\(codigo)): \(mensagem)")
    }
}

// If case let
let status: Status = .aprovado
if case .aprovado = status {
    print("Pedido aprovado!")
}

Protocolos

// Definindo protocolos
protocol Descritivel {
    var descricao: String { get }
}

protocol Validavel {
    func validar() -> Bool
}

// Extensão de protocolo com implementação padrão
extension Descritivel {
    var descricao: String {
        String(describing: self)
    }
}

// Múltiplos protocolos
struct Produto: Descritivel, Validavel, Codable {
    let id: UUID
    var nome: String
    var preco: Decimal
    
    var descricao: String {
        "\(nome) - R$ \(preco)"
    }
    
    func validar() -> Bool {
        !nome.isEmpty && preco > 0
    }
}

// Protocol-oriented design
protocol Repositorio {
    associatedtype Entidade
    
    func buscarTodos() async throws -> [Entidade]
    func buscar(id: UUID) async throws -> Entidade?
    func salvar(_ entidade: Entidade) async throws
    func deletar(id: UUID) async throws
}

Concorrência Moderna

// async/await
func buscarUsuario(id: UUID) async throws -> Usuario {
    let url = URL(string: "https://api.exemplo.com/usuarios/\(id)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(Usuario.self, from: data)
}

// Múltiplas tarefas em paralelo
func buscarDados() async throws -> (Usuario, [Produto]) {
    async let usuario = buscarUsuario(id: UUID())
    async let produtos = buscarProdutos()
    
    return try await (usuario, produtos)
}

// Task groups
func buscarTodosUsuarios(ids: [UUID]) async throws -> [Usuario] {
    try await withThrowingTaskGroup(of: Usuario.self) { group in
        for id in ids {
            group.addTask {
                try await self.buscarUsuario(id: id)
            }
        }
        
        var usuarios: [Usuario] = []
        for try await usuario in group {
            usuarios.append(usuario)
        }
        return usuarios
    }
}

// Actors para thread safety
actor ContadorSeguro {
    private var valor = 0
    
    func incrementar() {
        valor += 1
    }
    
    func obterValor() -> Int {
        valor
    }
}

SwiftUI Básico

import SwiftUI

struct ContentView: View {
    @StateObject private var viewModel = UsuariosViewModel()
    @State private var mostrarFormulario = false
    
    var body: some View {
        NavigationStack {
            List(viewModel.usuarios) { usuario in
                NavigationLink(destination: DetalheUsuarioView(usuario: usuario)) {
                    HStack {
                        Image(systemName: "person.circle")
                            .foregroundColor(.blue)
                        VStack(alignment: .leading) {
                            Text(usuario.nome)
                                .font(.headline)
                            Text(usuario.email)
                                .font(.caption)
                                .foregroundColor(.secondary)
                        }
                    }
                }
            }
            .navigationTitle("Usuários")
            .toolbar {
                Button(action: { mostrarFormulario = true }) {
                    Image(systemName: "plus")
                }
            }
            .sheet(isPresented: $mostrarFormulario) {
                NovoUsuarioView(viewModel: viewModel)
            }
        }
    }
}

Ferramentas Essenciais

Ferramenta	Propósito
Xcode	IDE oficial da Apple
Swift Package Manager	Gerenciador de dependências
TestFlight	Beta testing
Instruments	Profiling e debugging

Checklist de Aprendizado

• Dominar optionals e unwrapping
• Entender structs vs classes
• Aprender protocolos e extensions
• Estudar async/await e actors
• Praticar SwiftUI
• Explorar Combine framework
• Publicar um app na App Store

Recursos Essenciais

• Swift.org
• Apple Developer
• Hacking with Swift
• Swift by Sundell

Citação

“Swift é a linguagem mais poderosa e intuitiva que já criamos.” - Craig Federighi, Apple

---

Swift é a porta de entrada para o rico ecossistema Apple. Comece hoje e crie apps incríveis!