Swift Academy · Lektion

Komponera flera egenskapsomslagare

Kombinera egenskapsomslagare och förstå ordningen de initieras i.

Lektion 4 av 412 steg

Komponera flera egenskapsomslagare är en gratis lektion i Swift Academy på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Swift Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Swift Academy innehåller totalt 4 lektioner.

Välkommen

Flera property wrappers kan tillämpas på en och samma egenskap. Ordningen spelar roll — yttre omslag omsluter inre omslag — och initieringsordningen följer deklarationsordningen.

Stapla wrappers

```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 } ```

Den yttre omsluter den inre

När du skriver `@A @B var x` blir den utvidgade koden: ```swift var _x: A> = A(wrappedValue: B(wrappedValue: 0)) ``` A omsluter B, som omsluter Int.

Praktiskt exempel: @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 = " " } ```

Initieringsordning

Wrappers initieras från den yttersta till den innersta. Det innebär att den yttre wrapperns init tar emot resultatet av den inre wrapperns transformering – inte det ursprungliga värdet.

Begränsningar med att stapla wrappers

• Alla wrappers kan inte kombineras utan problem – kontrollera att typerna för `wrappedValue` matchar • Swift-kompilatorn tillåter inte alltid flera wrappers (det beror på om de omslutna typerna är kompatibla) • Åtkomst till `projectedValue` via `$x` når endast den yttersta wrapperns projection

SwiftUI-exempel: @EnvironmentObject + Observation

SwiftUI tillåter inte att `@EnvironmentObject` och `@Published` staplas på samma egenskap, men du kan observera modeller med `@EnvironmentObject` som använder `@Published` internt.

Felsöka staplade wrappers

Använd `_propertyName` för att komma åt wrapper-instansen direkt: ```swift print(form._username) // A> — the outer wrapper instance ```

Alternativ: kombinera inuti en wrapper

Ofta blir det tydligare att kombinera logiken i en enda wrapper: ```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 } } ```

Praktiska mönster för att stapla wrappers

Vanliga giltiga kombinationer: • `@UserDefault` + `@Published` (datalagring + observation) • `@NonNegative` + `@Clamped` (valideringslager) • Ramverksspecifikt: `@Environment` + `@Binding` i SwiftUI-vyer

Snabbtest

När två property wrappers staplas, vilken initieras först?

Sammanfattning

Viktiga punkter: • `@A @B var x` utvidgas till `A>` • Den yttre initieras med den inres `wrappedValue` som indata • `$x` når endast den yttersta wrapperns `projectedValue` • `_x` ger direkt åtkomst till wrapper-instansen • Föredra om möjligt en enda kombinerad wrapper framför djupa lager Kursen är klar! Nästa avsnitt: Result-typen.
Gratis att börja

Lär dig Swift med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
122
Lektioner
409

Vanliga frågor

Är lektionen ”Komponera flera egenskapsomslagare” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Swift Academy, inklusive ”Komponera flera egenskapsomslagare”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Swift Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Komponera flera egenskapsomslagare”?

Kombinera egenskapsomslagare och förstå ordningen de initieras i. Ni övar på Swift Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Swift Academy?

Du behöver inga förkunskaper. Utbildningen i Swift Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Komponera flera egenskapsomslagare”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Swift Academy-lektionen?

Ja. Varje Swift Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Skapa en anpassad egenskapsomslagare
  2. Projicerade värden med $binding
  3. @Published och observation i Combine
  4. Komponera flera egenskapsomslagare
← Tillbaka till Swift Academy