Minimização da Reavaliação de Body
Reduza recomputações desnecessárias das views.
Minimização da Reavaliação de Body é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.
body É Recalculado com Frequência
O SwiftUI chama o body de uma visualização sempre que suas entradas mudam. Um body pesado ou conectado a muitas dependências é recalculado com frequência excessiva, prejudicando o desempenho.
O Que Aciona a Reavaliação
Um body é executado novamente quando qualquer @State, @Binding, objeto observado ou valor do ambiente que ele lê muda — ou quando o elemento pai transmite novos valores.
struct Row: View {
let title: String // changes -> body re-runs
var body: some View { Text(title) }
}Restrinja o Que Você Observa
Se uma visualização lê um model grande inteiro, qualquer alteração nesse model executa novamente o body. Transmita apenas os valores específicos de que a visualização precisa.
// Instead of passing the whole model:
struct Price: View {
let amount: Decimal // narrow input
var body: some View { Text(amount, format: .currency(code: "USD")) }
}Divida Visualizações Grandes
Divida um body enorme em subvisualizações pequenas. O SwiftUI reavalia apenas as subvisualizações cujas entradas realmente mudaram, não a tela inteira.
struct Screen: View {
var body: some View {
VStack {
Header() // re-runs only if its inputs change
ItemList()
Footer()
}
}
}Observable e Rastreamento por Propriedade
Com a macro @Observable, o SwiftUI acompanha exatamente quais propriedades uma visualização lê. Uma visualização que lê apenas model.name ignora alterações em model.count.
@Observable final class Model {
var name = ""
var count = 0
}
// A view reading only name won’t re-run when count changesEvite Trabalho em body
O body deve descrever a interface de forma barata. Cálculos pesados (ordenação e filtragem) pertencem ao model ou a uma propriedade armazenada em cache, não devem ser refeitos a cada chamada de body.
// Bad: sort inside body (runs every recompute)
// Good: sort once in the model, expose sorted arrayClosures e Entradas Estáveis
Transmitir um vetor ou closure recém-criado a cada renderização pode impedir as verificações de igualdade do SwiftUI. Promova valores estáveis para que as entradas sejam consideradas iguais entre os recálculos.
// Hoist constants out of body
private let columns = [GridItem(.flexible())]Cuidado com Inicializadores Dispendiosos
O init de uma visualização pode ser executado muitas vezes. Evite trabalho pesado nele; o SwiftUI cria valores de visualização com frequência, mesmo quando não os renderiza.
struct Card: View {
init(_ item: Item) { /* keep this trivial */ }
var body: some View { Text("Card") }
}Leituras do Ambiente Têm um Custo nas Atualizações
Ler um valor do ambiente inscreve a visualização para receber atualizações dele. Leia valores do ambiente apenas onde forem necessários, na menor subvisualização possível, para limitar o escopo da reavaliação.
@Environment(\.colorScheme) private var schemeContêineres Preguiçosos
Use LazyVStack/LazyHStack e List para que as linhas fora da tela não sejam criadas até serem necessárias, reduzindo as chamadas de body em coleções grandes.
ScrollView {
LazyVStack {
ForEach(items) { RowView(item: $0) }
}
}Meça e Depois Otimize
Não tente adivinhar qual body está sobrecarregado. Use o Instrumento do SwiftUI para encontrar visualizações com muitas avaliações de body e aplique essas técnicas nelas.
Verificação Rápida: Reavaliação
Teste sua compreensão sobre a reavaliação de body.
Recapitulação: Minimizando a Reavaliação de body
Os bodies são executados novamente quando suas entradas mudam; portanto, transmita valores específicos, divida visualizações grandes em subvisualizações pequenas e aproveite o rastreamento por propriedade de @Observable. Mantenha bodies e inicializadores baratos, promova entradas estáveis, leia os valores do ambiente com moderação e use contêineres preguiçosos para coleções grandes.
Sempre confirme os pontos críticos com o Instrumento do SwiftUI antes de otimizar.
Perguntas Frequentes
A aula “Minimização da Reavaliação de Body” é grátis?
Sim — o texto completo de “Minimização da Reavaliação de Body” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.
O que vou aprender em “Minimização da Reavaliação de Body”?
Reduza recomputações desnecessárias das views. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Swift Academy?
Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Minimização da Reavaliação de Body”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Swift Academy?
Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Entendendo a Identidade das Views
- Minimização da Reavaliação de Body
- Views Equatable e Escopo de @State
- Criação de Perfil com o Instrument do SwiftUI