Swift Academy · Leçon

Composer plusieurs property wrappers

Empiler des property wrappers et comprendre leur ordre d’initialisation.

Composer plusieurs property wrappers est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Bienvenue

Plusieurs enveloppes de propriétés peuvent être appliquées à une seule propriété. L'ordre est important — les enveloppes externes enveloppent les enveloppes internes — et l'ordre d'initialisation suit l'ordre des déclarations.

Empilement des enveloppes

```swift @propertyWrapper struct A { var wrappedValue: Int { didSet { print("A") } } init(wrappedValue: Int) { self.wrappedValue = wrappedValue } } @propertyWrapper struct B { var wrappedValue: Int { didSet { print("B") } } init(wrappedValue: Int) { self.wrappedValue = wrappedValue } } struct S { @A @B var x = 0 } ```

L’enveloppe externe englobe l’interne

Lorsque vous écrivez `@A @B var x`, la transformation syntaxique donne : ```swift var _x: A> = A(wrappedValue: B(wrappedValue: 0)) ``` A englobe B, qui englobe Int.

Exemple concret : @NonEmpty + @Trimmed

```swift @propertyWrapper struct Trimmed { var wrappedValue: String { didSet { wrappedValue = wrappedValue.trimmingCharacters(in:.whitespaces) } } init(wrappedValue: String) { self.wrappedValue = wrappedValue.trimmingCharacters(in:.whitespaces) } } @propertyWrapper struct NonEmpty { var wrappedValue: String { didSet { if wrappedValue.isEmpty { wrappedValue = "(empty)" } } } init(wrappedValue: String) { self.wrappedValue = wrappedValue.isEmpty ? "(empty)" : wrappedValue } } struct Form { @NonEmpty @Trimmed var username = " " } ```

Ordre d’initialisation

Les enveloppes sont initialisées de l’extérieur vers l’intérieur. Cela signifie que l’initialiseur de l’enveloppe externe reçoit le résultat de la transformation effectuée par l’enveloppe interne, et non la valeur d’origine.

Limites de l’empilement

• Toutes les enveloppes ne se composent pas proprement : vérifiez que les types de `wrappedValue` correspondent • Le compilateur Swift n’autorise pas toujours plusieurs enveloppes, selon la compatibilité des types enveloppés • L’accès à `projectedValue` avec `$x` n’atteint que la projection de l’enveloppe la plus externe

Exemple SwiftUI : @EnvironmentObject + observation

SwiftUI n’autorise pas l’empilement de `@EnvironmentObject` et de `@Published` sur la même propriété, mais vous pouvez observer des modèles `@EnvironmentObject` qui utilisent `@Published` en interne.

Débogage des enveloppes empilées

Utilisez `_propertyName` pour accéder directement à l’instance de l’enveloppe : ```swift print(form._username) // A> — the outer wrapper instance ```

Autre possibilité : composer dans une seule enveloppe

Il est souvent plus clair de composer la logique dans une seule enveloppe : ```swift @propertyWrapper struct CleanUsername { var wrappedValue: String { didSet { wrappedValue = clean(wrappedValue) } } func clean(_ s: String) -> String { let t = s.trimmingCharacters(in:.whitespaces) return t.isEmpty ? "(empty)" : t } } ```

Schémas d’empilement pratiques

Empilements courants valides : • `@UserDefault` + `@Published` (persistance des données + observation) • `@NonNegative` + `@Clamped` (couches de validation) • Spécifique au framework : `@Environment` + `@Binding` dans les vues SwiftUI

Vérification rapide

Lorsque deux enveloppes de propriété sont empilées, laquelle s’initialise en premier ?

Récapitulatif

Points essentiels : • `@A @B var x` est transformé en `A>` • L’enveloppe externe s’initialise avec la valeur enveloppée de l’enveloppe interne comme entrée • `$x` n’atteint que le `projectedValue` de l’enveloppe la plus externe • `_x` accède directement à l’instance de l’enveloppe • Préférez une seule enveloppe composée à un empilement profond lorsque c’est possible Cours terminé ! Suite : le type Result.

Questions Fréquemment Posées

La leçon « Composer plusieurs property wrappers » est-elle gratuite ?

Oui — le texte complet de « Composer plusieurs property wrappers » 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 « Composer plusieurs property wrappers » ?

Empiler des property wrappers et comprendre leur ordre d’initialisation. 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 4 sur 4.

Combien de temps prend la leçon « Composer plusieurs property wrappers » ?

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