let e var em Swift: como a escolha afeta o desempenho

let e var em Swift: não apenas açúcar sintático, mas a chave para o desempenho

Se você já se perguntou "Qual é a diferença entre let e var em Swift?", você não está sozinho. No Stack Overflow, essa pergunta acumulou milhares de visualizações, e não é por acaso. À primeira vista, a resposta parece óbvia: let é uma constante, var é uma variável. Mas o diabo, como sempre, está nos detalhes. Neste artigo, não vamos apenas repetir o básico, mas sim olhar sob o capô do compilador Swift e descobrir como a escolha entre let e var afeta o desempenho da sua aplicação. Prontos? Vamos lá!

Fundamentos: o que dizem os livros?

Vamos começar pelo fundamento para termos uma base comum. Em Swift:

\n
• let — declara uma constante. O valor é definido uma vez e não pode mais ser alterado.
\n
• var — declara uma variável. O valor pode ser alterado quantas vezes quiser.
\n

Exemplo de código real:

let maximumLoginAttempts = 3 // Constante: número de tentativas é fixo\nvar currentLoginAttempt = 0  // Variável: será incrementada

Parece simples, não é? Mas se a diferença fosse apenas essa, a pergunta no Stack Overflow não teria atraído tanta atenção. A verdadeira mágica começa quando falamos sobre otimização.

Desempenho: por que let é frequentemente mais rápido que var

Muitos desenvolvedores pensam que let e var são apenas uma questão de estilo ou segurança. Na verdade, a escolha pode afetar a velocidade de execução do programa. Veja como isso funciona no nível do compilador.

1. Otimização pelo compilador (SIL e LLVM)

Swift usa um sistema de otimização em vários níveis. Primeiro, o código é transformado em SIL (Swift Intermediate Language) e depois em LLVM IR. Em cada etapa, o compilador toma decisões com base em se o valor é let ou var.

Quando você declara let, você dá ao compilador uma garantia de ferro: "Este valor nunca mudará". O compilador usa essa informação para:

\n
• Remover verificações redundantes: Se o valor da constante é usado em um loop, o compilador pode calculá-lo uma vez e armazená-lo em cache, em vez de recalculá-lo a cada iteração.
\n
• Inlining: Constantes são frequentemente incorporadas diretamente no código, eliminando a necessidade de acesso à memória.
\n
• Melhorar o gerenciamento de memória: Para let, o compilador pode usar estratégias de alocação de dados mais eficientes, pois sabe que a gravação nessa área de memória não será necessária.
\n

Com var, é mais complicado. O compilador não pode ter certeza de que o valor não mudará (mesmo que você não planeje alterá-lo). Portanto, ele é forçado a gerar um código mais conservador:

\n
• O valor é sempre armazenado na memória (e não apenas nos registradores da CPU).
\n
• Instruções adicionais são geradas para possíveis gravações.
\n
• Algumas otimizações relacionadas ao reordenamento de instruções são bloqueadas.
\n

Conclusão: let dá ao compilador mais liberdade para otimizar. Isso é especialmente perceptível em partes críticas do código — loops, funções recursivas, processamento de grandes arrays.

2. Semântica e threads (Thread Safety)

Outro aspecto do desempenho é o trabalho em ambiente multithread. let torna o código thread-safe por definição. Uma constante não pode ser alterada, portanto, não há risco de condição de corrida (race condition).

Com var, é diferente. Se uma variável é usada em várias threads, você precisará adicionar bloqueios (NSLock, DispatchQueue) ou usar operações atômicas. Isso inevitavelmente reduz o desempenho.

Compare as duas abordagens