Como otimizar a performance do SwiftUI em torno da identidade de view e do diffing?

Question

IT Interview Practice · Accepted Answer

O SwiftUI re-executa o `body` sempre que o estado observado muda, então faz o **diff** da nova árvore de views contra a antiga e atualiza apenas o que difere. Problemas de performance vêm de fazer esse diff trabalhar demais: **identidade** instável, **observação** ampla demais e computações de `body` custosas. Corrija controlando a identidade, restringindo o escopo do estado e mantendo o `body` barato.

## Como o diffing e a identidade funcionam

O SwiftUI casa views entre renders pela **identidade**. Para listas, essa é o `id`; se o id for instável, o SwiftUI descarta e reconstrói a view (perdendo estado e animações) em vez de atualizá-la.

```swift
// RUIM: índice do array como id — reordenar/inserir quebra a identidade, reconstrução total
ForEach(items.indices, id: \.self) { i in Row(items[i]) }

// BOM: identidade estável atrelada aos dados
ForEach(items) { item in Row(item) }      // items: Identifiable, id estável
```

## Restringindo o escopo da observação

Um `ObservableObject` re-renderiza **toda** view que o observa sempre que **qualquer** propriedade `@Published` muda. Divida modelos grandes, ou migre para o **Observation framework** (`@Observable`, iOS 17+), que rastreia leituras *por propriedade*, então uma view só re-renderiza quando uma propriedade que ela de fato usou muda.

```swift
@Observable final class Feed {     // iOS 17: rastreamento de dependência refinado
    var unreadCount = 0            // uma view lendo só .posts não re-renderiza com isto
    var posts: [Post] = []
}
```

## Mantendo o body barato

O `body` executa com frequência, então nunca faça trabalho pesado inline:

```swift
var body: some View {
    List(sortedItems) { ... }      // RUIM se sortedItems ordena a cada render
}
// BOM: compute dados derivados no modelo, não no body
```

- Extraia subviews para que uma mudança de estado re-renderize uma view **pequena**, não a tela inteira.
- Use `LazyVStack`/`List` para coleções grandes para que linhas fora da tela não sejam construídas.
- Adicione `.equatable()` ou `EquatableView` para curto-circuitar o diffing em subárvores estáveis.

## Armadilhas

- `AnyView` apaga a identidade de tipo e derrota o diffing estrutural — evite-o em caminhos quentes.
- Passar uma nova closure/array literal a cada render pode invalidar views filhas desnecessariamente.

## Por que isso importa

Em um display ProMotion de 120Hz você tem ~8ms por frame; um `body` que ordena um array grande ou re-renderiza uma lista inteira derruba frames e trava o scroll. Entrevistas sênior investigam identidade de view e escopo de observação porque é aí que apps SwiftUI reais ficam lentos — e onde algumas correções precisas restauram a fluidez.

Como o diffing e a identidade funcionam

Restringindo o escopo da observação

Mantendo o body barato

Armadilhas

Por que isso importa

Perguntas relacionadas