Swift Academy · Lektion

Einen benutzerdefinierten Property Wrapper erstellen

Implementieren Sie @propertyWrapper mit wrappedValue, um Logik zu kapseln.

Einen benutzerdefinierten Property Wrapper erstellen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

Property Wrapper kapseln die Logik zur Speicherung von Eigenschaften und ermöglichen die Wiederverwendung von Boilerplate-Code etwa für Validierung, Transformation oder Persistenz.

Grundlegende Syntax

```swift @propertyWrapper struct Clamped { var wrappedValue: Int { didSet { wrappedValue = min(max(0,wrappedValue),100) } } init(wrappedValue: Int) { self.wrappedValue = min(max(0,wrappedValue),100) } } struct Gauge { @Clamped var level = 50 } var g = Gauge() g.level = 150 // clamped to 100 ```

Die Anforderung an wrappedValue

Jeder Property Wrapper muss `wrappedValue` definieren. Darüber liest und schreibt der Benutzer des Wrappers.

Generische Property Wrapper

```swift @propertyWrapper struct Logged { private var value: T var wrappedValue: T { get { print("get"); return value } set { print("set to \(newValue)"); value = newValue } } init(wrappedValue: T) { value = wrappedValue } } ```

Den Wrapper verwenden

```swift struct Model { @Logged var name: String = "Default" } var m = Model() let n = m.name // prints "get" m.name = "Alice" // prints "set to Alice" ```

Benutzerdefinierte Initialisierungsargumente

```swift @propertyWrapper struct Default { var wrappedValue: T init(wrappedValue: T) { self.wrappedValue = wrappedValue } init(_ default: T) { wrappedValue = default } } @Default(42) var count: Int ```

Wrapper für gespeicherte vs. berechnete Eigenschaften

Property Wrapper fügen einen verborgenen Speicher (_wrappedValue) hinzu. Die annotierte Eigenschaft ist syntaktischer Zucker: ```swift @Clamped var level = 50 // Desugars to: var _level = Clamped(wrappedValue: 50) var level: Int { get { _level.wrappedValue } set { _level.wrappedValue = newValue } } ```

UserDefaults-Wrapper

```swift @propertyWrapper struct UserDefault { let key: String; let defaultValue: T var wrappedValue: T { get { UserDefaults.standard.object(forKey: key) as? T ?? defaultValue } set { UserDefaults.standard.set(newValue, forKey: key) } } } @UserDefault(key:"theme",defaultValue:"light") var theme: String ```

Thread-sicherer Wrapper

```swift @propertyWrapper final class Atomic { private var value: T; private let lock = NSLock() var wrappedValue: T { get { lock.lock(); defer { lock.unlock() }; return value } set { lock.lock(); defer { lock.unlock() }; value = newValue } } init(wrappedValue: T) { value = wrappedValue } } ```

Wrapper in einem Typ kombinieren

```swift struct Settings { @Clamped var volume = 50 @UserDefault(key:"username",defaultValue:"") var username: String @Logged var debugMode = false } ```

Kurze Überprüfung

Welche Eigenschaft ist in jedem `@propertyWrapper`-Typ erforderlich?

Zusammenfassung

Wichtige Erkenntnisse: • `@propertyWrapper` + `wrappedValue` = minimaler Property Wrapper • Der Wrapper fügt einen verborgenen `_name`-Speicher hinzu • Generische Wrapper funktionieren mit jedem Typ T • Häufige Anwendungsfälle: Begrenzung, Protokollierung, UserDefaults, Thread-Sicherheit • Benutzerdefinierte Initialisierungsargumente ermöglichen Konfiguration Nächster Abschnitt: projizierte Werte.

Häufig gestellte Fragen

Ist die Lektion „Einen benutzerdefinierten Property Wrapper erstellen“ kostenlos?

Ja — der vollständige Text von „Einen benutzerdefinierten Property Wrapper erstellen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Einen benutzerdefinierten Property Wrapper erstellen“?

Implementieren Sie @propertyWrapper mit wrappedValue, um Logik zu kapseln. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Einen benutzerdefinierten Property Wrapper erstellen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Einen benutzerdefinierten Property Wrapper erstellen
Projizierte Werte mit $binding
@Published und Observation in Combine
Mehrere Property Wrapper kombinieren

← Zurück zu Swift Academy