Swift Academy · Lezione

Riduzione della rivalutazione del body

Riduci le ricalcolazioni non necessarie delle view.

Riduzione della rivalutazione del body è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Il body viene ricalcolato spesso

SwiftUI chiama il body di una vista ogni volta che cambiano i suoi input. Un body pesante o con troppe dipendenze viene ricalcolato troppo spesso, danneggiando le prestazioni.

Che cosa attiva la rivalutazione

Un body viene rieseguito quando cambia un qualsiasi @State, @Binding, oggetto osservato o valore dell'ambiente che legge, oppure quando il genitore gli passa nuovi valori.

struct Row: View {
    let title: String // changes -> body re-runs
    var body: some View { Text(title) }
}

Restringa ciò che osserva

Se una vista legge un intero modello di grandi dimensioni, ogni modifica a quel modello riesegue il body. Passi solo i valori specifici di cui la vista ha bisogno.

// Instead of passing the whole model:
struct Price: View {
    let amount: Decimal // narrow input
    var body: some View { Text(amount, format: .currency(code: "USD")) }
}

Suddivida le viste grandi

Scomponga un body enorme in piccole sottoviste. SwiftUI rivaluta solo le sottoviste i cui input sono effettivamente cambiati, non l'intera schermata.

struct Screen: View {
    var body: some View {
        VStack {
            Header()   // re-runs only if its inputs change
            ItemList()
            Footer()
        }
    }
}

Observable e tracciamento a livello di proprietà

Con la macro @Observable, SwiftUI tiene traccia delle proprietà esatte lette da una vista. Una vista che legge solo model.name ignora le modifiche a model.count.

@Observable final class Model {
    var name = ""
    var count = 0
}
// A view reading only name won’t re-run when count changes

Eviti il lavoro nel body

Il body dovrebbe descrivere l'interfaccia in modo rapido. I calcoli pesanti, come l'ordinamento e il filtraggio, appartengono al modello o a una proprietà memorizzata nella cache, non devono essere ricalcolati a ogni chiamata del body.

// Bad: sort inside body (runs every recompute)
// Good: sort once in the model, expose sorted array

Closure e input stabili

Passare un array o una closure creata nuovamente a ogni rendering può vanificare i controlli di uguaglianza di SwiftUI. Porti i valori stabili a un livello esterno, così gli input risultano uguali tra i vari ricalcoli.

// Hoist constants out of body
private let columns = [GridItem(.flexible())]

Attenzione agli inizializzatori costosi

Il metodo init di una vista può essere eseguito molte volte. Eviti di svolgervi operazioni pesanti; SwiftUI crea frequentemente valori delle viste anche quando non li visualizza.

struct Card: View {
    init(_ item: Item) { /* keep this trivial */ }
    var body: some View { Text("Card") }
}

La lettura dell'ambiente comporta aggiornamenti

Leggere un valore dell'ambiente iscrive la vista alle sue modifiche. Legga i valori dell'ambiente solo dove servono, nella sottovista più piccola possibile, per limitare l'ambito della rivalutazione.

@Environment(\.colorScheme) private var scheme

Contenitori lazy

Utilizzi LazyVStack/LazyHStack e List affinché le righe fuori schermo non vengano create finché non servono, riducendo le chiamate al body per raccolte di grandi dimensioni.

ScrollView {
    LazyVStack {
        ForEach(items) { RowView(item: $0) }
    }
}

Misuri, poi ottimizzi

Non indovini quale body sia più sollecitato. Utilizzi SwiftUI Instrument per individuare le viste con un numero elevato di rivalutazioni del body, quindi applichi queste tecniche proprio lì.

Verifica rapida: rivalutazione

Verifichi la Sua comprensione della rivalutazione del body.

Riepilogo: riduzione della rivalutazione del body

I body vengono rieseguiti quando cambiano i loro input; passi quindi valori mirati, suddivida le viste grandi in piccole sottoviste e sfrutti il tracciamento a livello di proprietà di @Observable. Mantenga rapidi body e inizializzatori, porti i valori stabili a un livello esterno, legga i valori dell'ambiente solo quando necessario e utilizzi contenitori lazy per le raccolte grandi.

Confermi sempre i punti critici con SwiftUI Instrument prima di ottimizzare.

Domande Frequenti

La lezione «Riduzione della rivalutazione del body» è gratuita?

Sì — il testo completo di «Riduzione della rivalutazione del body» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «Riduzione della rivalutazione del body»?

Riduci le ricalcolazioni non necessarie delle view. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Riduzione della rivalutazione del body»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Swift Academy