Como acelerar Swift: perfilamento e otimização de código

Por que o Swift está lento? Entendendo o desempenho

Você já iniciou seu aplicativo Swift e sentiu que ele estava funcionando… bem, como uma lesma na hora do rush? A tela trava, as animações ficam instáveis e os usuários já estão prontos para dar uma estrela na App Store. Dor familiar? Bem-vindo ao clube!

Swift é uma linguagem rápida. A Apple prometeu isso e, em 90% dos casos, é verdade. Mas há um detalhe: até a linguagem mais poderosa pode ser "sufocada" por arquitetura ruim, vazamentos de memória ou algoritmos ineficientes. Neste artigo, não vamos dar aulas chatas. Em vez disso, vou mostrar ferramentas e técnicas reais que transformarão seu aplicativo de tartaruga em guepardo.

Prontos? Vamos lá!

Ferramentas de perfilamento: seu raio-X para o código

Antes de otimizar qualquer coisa, você precisa entender o que exatamente está lento. Adivinhar não é uma boa estratégia. É aqui que o perfilamento de código Swift entra em ação.

Xcode Instruments — seu melhor amigo

O Xcode tem um conjunto de ferramentas integrado — Instruments. É como uma ressonância magnética para seu aplicativo: mostra cada detalhe, cada chamada de função e cada byte de memória. Inicia-se facilmente: Product > Profile (ou Cmd + I).

Aqui estão três modelos mais úteis:

\n
• Time Profiler — mostra quais funções consomem mais tempo de CPU.
\n
• Allocations — rastreia alocação e liberação de memória.
\n
• Leaks — detecta vazamentos de memória (sim, no Swift eles também acontecem!).
\n

Exemplo: você executa o Time Profiler, rola uma tabela — e vê que 70% do tempo vai para tableView(_:cellForRowAt:). Isso é um sinal: é hora de otimizar as células.

Signposts e os_log: perfilamento sem Instruments

Instruments é poderoso, mas nem sempre está à mão. Às vezes, você precisa medir rapidamente o desempenho diretamente no código. É aqui que os Signposts (iOS 12+) ajudam:

import os.signpost\n\nlet log = OSLog(subsystem: "com.yourapp.networking", category: .pointsOfInterest)\nlet signpostID = OSSignpostID(log: log)\n\nos_signpost(.begin, log: log, name: "fetchData", signpostID: signpostID)\n// seu código de carregamento de dados\nos_signpost(.end, log: log, name: "fetchData", signpostID: signpostID)\n

Depois, abra o Instruments, selecione os_signpost — e veja os timestamps. Bonito, né?

Otimização de código Swift: do simples ao complexo

Agora que sabemos onde estão os gargalos, vamos corrigi-los. Dividi as dicas em três níveis: para iniciantes, para experientes e para profissionais.

1. Nível básico: o que qualquer um pode fazer

Vamos começar pelo óbvio, mas frequentemente esquecido.

Use value types (struct) em vez de reference types (class)

Isso é clássico no Swift. Struct é armazenado na pilha, class — no heap. A pilha é rápida, o heap é lento (precisa alocar memória, contar referências). Se seu objeto é pequeno e não requer herança — faça dele uma struct sem medo.

// Ruim (class)\nclass User {\n    var name: String\n    var age: Int\n    init(name: String, age: Int) {\n        self.name = name\n        self.age = age\n    }\n}\n\n// Bom (struct)\nstruct User {\n    var name: String\n    var age: Int\n}\n

Inicialização preguiçosa (lazy)

Por que criar um objeto se ele pode não ser necessário? Use lazy var:

class DataManager {\n    lazy var networkService = NetworkService() // será criado apenas no primeiro acesso\n}\n

Evite cópias desnecessárias

Toda vez que você passa um array para uma função, o Swift pode copiá-lo (se for Array — value type). Use inout ou UnsafeMutablePointer para dados grandes.

2. S