0Pricing
Swift Academy · Lektion

@Published und Observation in Combine

Wie @Published intern funktioniert, um Änderungen über Combine-Publisher auszugeben.

@Published und Observation in Combine ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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

`@Published` ist ein Property Wrapper aus dem Combine-Framework, der jedes Mal, wenn sich die Eigenschaft ändert, über einen Publisher einen neuen Wert ausgibt.

Grundlagen zu @Published

```swift import Combine class Counter: ObservableObject { @Published var count = 0 } let c = Counter() let cancel = c.$count.sink { print("Count: \($0)") } c.count += 1 // "Count: 1" c.count += 1 // "Count: 2" ```

ObservableObject-Protokoll

```swift class ViewModel: ObservableObject { @Published var title = "Initial" @Published var items: [String] = [] } ``` Jede Klasse, die `ObservableObject` entspricht, erhält automatisch einen `objectWillChange`-Publisher.

objectWillChange-Publisher

```swift class VM: ObservableObject { @Published var name = "" } let vm = VM() let cancel = vm.objectWillChange.sink { print("Will change") } vm.name = "Alice" // "Will change" printed before assignment ```

@Published mit SwiftUI @StateObject

```swift @StateObject var vm = ViewModel() // In View body: Text(vm.title) // Re-renders when vm.title changes ``` `@StateObject` besitzt das ViewModel; `@ObservedObject` beobachtet eines, das extern verwaltet wird.

Publisher von @Published verketten

```swift class Search: ObservableObject { @Published var query = "" @Published var results: [String] = [] private var cancellables = Set() init() { $query .debounce(for: 0.3, scheduler: RunLoop.main) .sink { [weak self] q in self?.search(q) } .store(in: &cancellables) } } ```

@Published wird vor der Zuweisung ausgelöst

`objectWillChange` wird *vor* dem Speichern des neuen Werts ausgelöst: ```swift vm.objectWillChange.sink { _ in print("will change") } $count.sink { n in print("is \(n)") } // Order: "will change" then "is 1" ```

Abonnements speichern

```swift var cancellables = Set() c.$count .sink { print("\($0)") } .store(in: &cancellables) // cancellables keeps subscription alive ```

Einschränkungen von @Published

• Nur für Klassen (Referenztypen) • Kann nicht für `let`-Konstanten verwendet werden • Funktioniert ohne explizite Isolation nicht über Actor-Grenzen hinweg • Der Wert wird *vor* dem Abschluss der Zuweisung ausgegeben (`willSet`-Semantik)

Observation-Makro (Swift 5.9+)

Swift 5.9 führt `@Observable` als einfachere Alternative ein: ```swift @Observable class Counter { var count = 0 } // No Combine import needed; SwiftUI auto-subscribes ```

Kurze Überprüfung

Wann gibt `@Published` seinen Wert aus – bevor oder nachdem die Eigenschaft gesetzt wird?

Zusammenfassung

Wichtige Erkenntnisse: • `@Published var x` stellt `$x` als `Publisher` bereit • `ObservableObject` erhält automatisch einen `objectWillChange`-Publisher • Wird ausgelöst, bevor der neue Wert gespeichert wird (`willSet`) • Abonnements in `Set` speichern • Swift 5.9: `@Observable` deckt die meisten Anwendungsfälle von `@Published` ab Nächster Abschnitt: Property Wrapper kombinieren.

Häufig gestellte Fragen

Ist die Lektion „@Published und Observation in Combine“ kostenlos?

Ja — der vollständige Text von „@Published und Observation in Combine“ 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 „@Published und Observation in Combine“?

Wie @Published intern funktioniert, um Änderungen über Combine-Publisher auszugeben. 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 3 von 4.

Wie lange dauert die Lektion „@Published und Observation in Combine“?

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

  1. Einen benutzerdefinierten Property Wrapper erstellen
  2. Projizierte Werte mit $binding
  3. @Published und Observation in Combine
  4. Mehrere Property Wrapper kombinieren
← Zurück zu Swift Academy