Swift Academy · Lektion

Projizierte Werte mit $binding

Stellen Sie über projectedValue zusätzliche Funktionen mit dem $-Präfix bereit.

Projizierte Werte mit $binding ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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

Projizierte Werte (über `$` abgerufen) geben Property Wrappers eine zusätzliche Schnittstelle – SwiftUI verwendet sie bei `@State` und `@Published`, um `Binding` und `Publisher` bereitzustellen.

projectedValue hinzufügen

```swift @propertyWrapper struct Toggle { var wrappedValue: Bool = false var projectedValue: String { wrappedValue ? "ON" : "OFF" } } struct Model { @Toggle var active } var m = Model() print(m.$active) // "OFF" — projected value accessed with $ ```

Typ von projectedValue

Der projizierte Wert kann jeden Typ haben – ein `Binding`, ein `Publisher`, ein `String` oder ein benutzerdefinierter Typ. SwiftUIs `@State` projiziert ein `Binding`, das einen bidirektionalen Datenfluss ermöglicht.

Beispiel für eine Binding-Projektion

```swift // @State projects Binding: @State var isOn = false Toggle(isOn: $isOn) // $isOn is Binding ```

Benutzerdefinierte Binding-Projektion

```swift @propertyWrapper struct Validated { var wrappedValue: String var projectedValue: Bool { !wrappedValue.isEmpty } } struct Form { @Validated var email = "" } var f = Form() f.email = "hi@example.com" print(f.$email) // true — projected Bool ```

@Published-Projektion

```swift class VM: ObservableObject { @Published var score = 0 } let vm = VM() let cancellable = vm.$score // Publisher .sink { print("Score: \($0)") } vm.score = 10 // "Score: 10" ```

Auf projectedValue innerhalb des Wrappers zugreifen

```swift @propertyWrapper struct History { private var current: T private(set) var projectedValue: [T] = [] var wrappedValue: T { get { current } set { projectedValue.append(current); current = newValue } } init(wrappedValue: T) { current = wrappedValue } } ```

Den History-Wrapper verwenden

```swift struct Counter { @History var count = 0 } var c = Counter() c.count = 1; c.count = 5; c.count = 3 print(c.$count) // [0,1,5] — history of old values ```

$-Syntax unterscheiden

```swift struct Form { @State var text = "" var body: some View { TextField("Enter", text: $text) // $text is Binding } } // text → String (wrappedValue) // $text → Binding (projectedValue) ```

Überlegungen zum Design

• `projectedValue` ist optional – fügen Sie es nur hinzu, wenn eine zusätzliche Schnittstelle benötigt wird • Der Typ kann sich vollständig von `wrappedValue` unterscheiden • Verwenden Sie `$` an der Aufrufstelle, um den projizierten Wert abzurufen • Projizierte Werte eignen sich hervorragend für Combine-Publisher und SwiftUI-Bindings

Kurze Überprüfung

Wie greifen Sie auf den `projectedValue` eines Property Wrappers zu?

Zusammenfassung

Wichtige Erkenntnisse: • `projectedValue` gibt Wrappern über `$` eine zusätzliche API • Kann jeder Typ sein – Binding, Publisher, Bool, Array • `@State` projiziert `Binding`; `@Published` projiziert `Publisher` • Zugriff mit `$propertyName` sowohl im Body als auch an der Aufrufstelle • Nur hinzufügen, wenn eine zweite Schnittstelle einen echten Mehrwert bietet Nächster Abschnitt: @Published und Combine.

Häufig gestellte Fragen

Ist die Lektion „Projizierte Werte mit $binding“ kostenlos?

Ja — der vollständige Text von „Projizierte Werte mit $binding“ 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 „Projizierte Werte mit $binding“?

Stellen Sie über projectedValue zusätzliche Funktionen mit dem $-Präfix bereit. 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 2 von 4.

Wie lange dauert die Lektion „Projizierte Werte mit $binding“?

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