Swift Academy · Lektion

@ObservableObject und @StateObject

Erstellen Sie Referenztypen-Modelle, die SwiftUI-Views über @Published steuern.

@ObservableObject und @StateObject 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

Für komplexe Zustände, die von mehreren Ansichten gemeinsam verwendet werden, verwenden Sie Referenztypmodelle, die `ObservableObject` entsprechen, von `@StateObject` besessen oder von `@ObservedObject` beobachtet werden.

Ein ObservableObject definieren

```swift class CartModel: ObservableObject { @Published var items: [CartItem] = [] @Published var total: Double = 0 func add(_ item: CartItem) { items.append(item) } } ```

@StateObject — Besitz

```swift struct ShopView: View { @StateObject private var cart = CartModel() // owns the model var body: some View { CartList(cart: cart) } } ``` Verwenden Sie `@StateObject`, wenn die Ansicht das Modell erstellt und besitzt.

@ObservedObject — Externer Besitz

```swift struct CartList: View { @ObservedObject var cart: CartModel // doesn't own; passed in var body: some View { List(cart.items) { item in Text(item.name) } } } ```

Der Unterschied

• `@StateObject` — die Ansicht erstellt das Modell; das Modell bleibt über erneute Renderdurchläufe hinweg erhalten • `@ObservedObject` — das Modell wird übergeben und kann von der übergeordneten Ansicht neu erstellt werden Wenn Sie `@ObservedObject` verwenden, obwohl `@StateObject` erforderlich wäre, wird das Modell unerwartet zurückgesetzt.

objectWillChange-Abonnement

SwiftUI abonniert `objectWillChange` automatisch, wenn Sie `@StateObject` oder `@ObservedObject` verwenden. Jede Änderung an `@Published` löst einen erneuten Renderdurchlauf aus.

Manuelles objectWillChange

```swift class Timer: ObservableObject { var count = 0 func tick() { objectWillChange.send() // manual notification count += 1 } } ```

Verschachtelte ObservableObjects

SwiftUI beobachtet verschachtelte ObservableObjects nicht automatisch. Leiten Sie Änderungen manuell weiter: ```swift class Parent: ObservableObject { @Published var child = ChildModel() private var cancel: AnyCancellable? init() { cancel = child.objectWillChange.sink { [weak self] _ in self?.objectWillChange.send() } } } ```

@Observable-Makro (Swift 5.9)

```swift @Observable class Counter { var count = 0 } // No ObservableObject, no @Published, no @StateObject needed // SwiftUI automatically tracks access ```

ObservableObject testen

```swift func testCart() { let cart = CartModel() cart.add(CartItem(name:"Apple",price:1.0)) XCTAssertEqual(cart.items.count, 1) XCTAssertEqual(cart.total, 1.0) } ```

Kurzer Test

Wann sollten Sie `@StateObject` und wann `@ObservedObject` verwenden?

Zusammenfassung

Die wichtigsten Punkte: • `ObservableObject` + `@Published` = reaktives Modell • `@StateObject` — die Ansicht besitzt das Modell; es bleibt über erneute Renderdurchläufe hinweg erhalten • `@ObservedObject` — das Modell wird übergeben; der Besitz liegt außerhalb der Ansicht • `objectWillChange.send()` für manuelle Benachrichtigungen • Das Swift-5.9-`@Observable`-Makro ersetzt den größten Teil dieser Vorgehensweise Als Nächstes: @EnvironmentObject.

Häufig gestellte Fragen

Ist die Lektion „@ObservableObject und @StateObject“ kostenlos?

Ja — der vollständige Text von „@ObservableObject und @StateObject“ 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 „@ObservableObject und @StateObject“?

Erstellen Sie Referenztypen-Modelle, die SwiftUI-Views über @Published steuern. 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 „@ObservableObject und @StateObject“?

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

@Binding: Zwei-Wege-Datenfluss
@ObservableObject und @StateObject
@EnvironmentObject für gemeinsam genutzten Zustand
Single Source of Truth und unidirektionaler Datenfluss

← Zurück zu Swift Academy