Swift Academy · Leçon

Minimiser la réévaluation de Body

Réduisez les recalculs inutiles des vues.

Minimiser la réévaluation de Body est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

body est souvent recalculé

SwiftUI appelle le body d’une vue chaque fois que ses entrées changent. Un body lourd ou trop connecté est recalculé trop fréquemment, ce qui dégrade les performances.

Ce qui déclenche une réévaluation

Un body est réexécuté lorsqu’un @State, un @Binding, un objet observé ou une valeur d’environnement qu’il lit change, ou lorsque son parent lui transmet de nouvelles valeurs.

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

Limitez ce que vous observez

Si une vue lit un modèle complet et volumineux, toute modification de ce modèle réexécute son body. Ne transmettez que les valeurs précises dont la vue a besoin.

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

Divisez les grandes vues

Décomposez un body gigantesque en petites sous-vues. SwiftUI réévalue uniquement les sous-vues dont les entrées ont réellement changé, et non tout l’écran.

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

Observable et suivi au niveau des propriétés

Avec la macro @Observable, SwiftUI suit les propriétés exactes qu’une vue lit. Une vue qui ne lit que model.name ignore les changements de model.count.

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

Évitez le travail dans body

Le body doit décrire l’interface à peu de frais. Les calculs lourds (tri, filtrage) doivent se trouver dans le modèle ou dans une propriété mise en cache, et non être recalculés à chaque appel du body.

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

Closures et entrées stables

Transmettre un tableau ou une closure nouvellement créé à chaque rendu peut empêcher les vérifications d’égalité de SwiftUI de fonctionner efficacement. Remontez les valeurs stables afin que les entrées restent égales entre les recalculs.

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

Méfiez-vous des initialiseurs coûteux

Le init d’une vue peut être exécuté de nombreuses fois. Évitez d’y effectuer un travail lourd : SwiftUI crée fréquemment des valeurs de vue, même lorsqu’il ne les affiche pas.

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

La lecture de l’environnement entraîne des mises à jour

Lire une valeur d’environnement y abonne la vue. Ne lisez les valeurs d’environnement que là où elles sont nécessaires, dans la plus petite sous-vue possible, afin de limiter la portée de la réévaluation.

@Environment(\.colorScheme) private var scheme

Conteneurs différés

Utilisez LazyVStack/LazyHStack et List afin que les lignes hors écran ne soient créées qu’au moment nécessaire, réduisant ainsi les appels à body pour les grandes collections.

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

Mesurez, puis optimisez

Ne devinez pas quel body est le plus sollicité. Utilisez l’instrument SwiftUI pour trouver les vues dont le nombre d’évaluations du body est élevé, puis appliquez-y ces techniques.

Vérification rapide : réévaluation

Vérifiez votre compréhension de la réévaluation du body.

Récapitulatif : réduire la réévaluation du body

Les body sont réexécutés lorsque leurs entrées changent. Transmettez donc des valeurs ciblées, divisez les grandes vues en petites sous-vues et appuyez-vous sur le suivi au niveau des propriétés de @Observable. Gardez les body et les initialiseurs légers, remontez les entrées stables, lisez les valeurs d’environnement avec parcimonie et utilisez des conteneurs différés pour les grandes collections.

Confirmez toujours les points sensibles avec l’instrument SwiftUI avant d’optimiser.

Questions Fréquemment Posées

La leçon « Minimiser la réévaluation de Body » est-elle gratuite ?

Oui — le texte complet de « Minimiser la réévaluation de Body » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Minimiser la réévaluation de Body » ?

Réduisez les recalculs inutiles des vues. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Minimiser la réévaluation de Body » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Swift Academy