Come si ottimizzano le prestazioni di SwiftUI attorno all'identità delle view e al diffing?

Question

IT Interview Practice · Accepted Answer

SwiftUI riesegue `body` ogni volta che lo stato osservato cambia, poi fa il **diff** del nuovo albero di view contro quello vecchio e aggiorna solo ciò che differisce. I problemi di prestazioni derivano dal far fare a quel diff troppo lavoro: **identità** instabile, **osservazione** troppo ampia e calcoli di `body` costosi. Risolvi controllando l'identità, delimitando lo stato e mantenendo `body` economico.

## Come funzionano diffing e identità

SwiftUI abbina le view tra i render tramite l'**identità**. Per le liste questa è l'`id`; se l'id è instabile, SwiftUI butta via e ricostruisce la view (perdendo stato e animazioni) invece di aggiornarla.

```swift
// MALE: indice dell'array come id — riordini/inserimenti rompono l'identità, ricostruzione completa
ForEach(items.indices, id: \.self) { i in Row(items[i]) }

// BENE: identità stabile legata ai dati
ForEach(items) { item in Row(item) }      // items: Identifiable, id stabile
```

## Delimitare l'osservazione

Un `ObservableObject` ri-renderizza **ogni** view che lo osserva ogni volta che **una qualsiasi** proprietà `@Published` cambia. Suddividi i model grandi, oppure passa all'**Observation framework** (`@Observable`, iOS 17+), che traccia le letture *per-proprietà* così una view si ri-renderizza solo quando una proprietà che ha effettivamente usato cambia.

```swift
@Observable final class Feed {     // iOS 17: tracciamento fine delle dipendenze
    var unreadCount = 0            // una view che legge solo .posts non si ri-renderizza per questo
    var posts: [Post] = []
}
```

## Mantenere body economico

`body` viene eseguito spesso, quindi non fare mai lavoro pesante inline:

```swift
var body: some View {
    List(sortedItems) { ... }      // MALE se sortedItems ordina a ogni render
}
// BENE: calcola i dati derivati nel model, non in body
```

- Estrai le subview così un cambio di stato ri-renderizza una **piccola** view, non l'intera schermata.
- Usa `LazyVStack`/`List` per grandi collezioni così le righe fuori schermo non vengono costruite.
- Aggiungi `.equatable()` o `EquatableView` per cortocircuitare il diffing su sottoalberi stabili.

## Insidie

- `AnyView` cancella l'identità di tipo e vanifica il diffing strutturale — evitalo nei percorsi critici.
- Passare una nuova closure/array literal a ogni render può invalidare le child view inutilmente.

## Perché è importante

Su un display ProMotion a 120Hz hai circa 8ms per frame; un `body` che ordina un array grande o ri-renderizza un'intera lista fa cadere frame e crea scatti nello scroll. I colloqui senior indagano su identità delle view e scope di osservazione perché è lì che le vere app SwiftUI diventano lente — ed è lì che pochi accorgimenti precisi ripristinano la fluidità.

Come funzionano diffing e identità

Delimitare l'osservazione

Mantenere body economico

Insidie

Perché è importante

Domande correlate