Swift Academy · Leçon

Vues Equatable et portée de @State

Limitez l’état pour réduire les invalidations.

Vues Equatable et portée de @State est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

L’égalité peut éviter du travail

Si SwiftUI peut prouver que les entrées d’une vue n’ont pas changé, il peut éviter de la restituer. Rendre une vue Equatable fournit à SwiftUI un moyen précis de le décider.

Rendre une vue conforme à Equatable

Rendez votre vue conforme à Equatable afin que SwiftUI compare les anciennes et les nouvelles valeurs. Si elles sont égales, il ignore le body.

struct Badge: View, Equatable {
    let count: Int
    var body: some View { Text("\(count)") }
    static func == (a: Badge, b: Badge) -> Bool {
        a.count == b.count
    }
}

EquatableView

Vous pouvez aussi envelopper toute vue Equatable avec .equatable() pour demander une exclusion fondée sur la comparaison, sans modifier les sites d’appel du type partout.

Badge(count: total)
    .equatable()

Quand Equatable est utile

Equatable est particulièrement utile pour les vues dont les entrées sont peu coûteuses à comparer, mais dont le body est coûteux. Le coût de la comparaison doit être largement inférieur à celui du rendu pour que cela soit avantageux.

Le piège du coût de la comparaison

Si votre == est lui-même coûteux, par exemple pour comparer en profondeur de grands tableaux, il peut coûter plus cher que le rendu que vous essayez d’éviter. Comparez uniquement des champs peu coûteux et décisifs.

static func == (a: Self, b: Self) -> Bool {
    a.id == b.id && a.version == b.version // cheap fields
}

Equatable synthétisé par défaut

Si toutes les propriétés stockées sont Equatable, Swift peut synthétiser ==. Cependant, les fermetures et certains types ne sont pas Equatable ; vous devrez donc peut-être écrire une implémentation personnalisée qui les ignore.

struct Card: View, Equatable {
    let title: String
    let onTap: () -> Void // not Equatable
    static func == (a: Card, b: Card) -> Bool { a.title == b.title }
    var body: some View { Text(title) }
}

Réduire la portée de @State

Un état placé trop haut entraîne un nouveau rendu de tout ce qui se trouve en dessous. Descendez @State jusqu’à la plus petite vue qui en est propriétaire, afin que les changements affectent le moins d’éléments possible de l’interface.

// Move toggle state into the row that uses it
struct Row: View {
    @State private var expanded = false
    var body: some View { /* only this row re-renders */ Text("Row") }
}

Ne remonter l’état que s’il est partagé

Ne remontez l’état que lorsque plusieurs vues en ont réellement besoin. Sinon, un état local maintient à un niveau réduit la zone affectée par un nouveau rendu.

Extraire des sous-vues pour localiser les mises à jour

Extraire une partie qui change fréquemment dans sa propre vue limite la réévaluation à cette vue et laisse ses voisines intactes.

struct LiveClock: View {
    @State private var now = Date()
    var body: some View { Text(now, style: .time) }
}

Liaisons et portée

Un @Binding relie un enfant à l’état de son parent. Transmettre une liaison ciblée, portant sur un seul champ, plutôt que l’objet entier limite les changements qui se propagent.

struct NameField: View {
    @Binding var name: String // narrow binding
    var body: some View { TextField("Name", text: $name) }
}

Combiner Equatable et la portée

Les meilleurs résultats s’obtiennent en combinant plusieurs techniques : limiter l’emplacement de l’état pour réduire les déclencheurs, puis utiliser Equatable pour ignorer les rendus qui se produisent encore.

Vérification rapide : vues Equatable

Vérifiez votre compréhension des vues Equatable et de la portée de l’état.

Récapitulatif : vues Equatable et portée de l’état

Rendre une vue Equatable, ou utiliser .equatable(), permet à SwiftUI d’ignorer les rendus inchangés, ce qui est avantageux lorsque la comparaison est bien moins coûteuse que le rendu et ne porte que sur des champs décisifs.

Limitez @State à la plus petite vue qui en est propriétaire, transmettez des liaisons ciblées et extrayez les parties instables dans leurs propres vues. Combiner une portée d’état restreinte avec Equatable produit le moins de nouveaux rendus possible, au coût le plus faible.

Questions Fréquemment Posées

La leçon « Vues Equatable et portée de @State » est-elle gratuite ?

Oui — le texte complet de « Vues Equatable et portée de @State » 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 « Vues Equatable et portée de @State » ?

Limitez l’état pour réduire les invalidations. 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 3 sur 4.

Combien de temps prend la leçon « Vues Equatable et portée de @State » ?

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