0Pricing
Swift Academy · Lekcja

@ObservableObject i @StateObject

Tworzenie modeli typu referencyjnego sterujących widokami SwiftUI za pośrednictwem @Published.

@ObservableObject i @StateObject to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wprowadzenie

W przypadku złożonego stanu współdzielonego przez wiele widoków należy używać modeli będących typami referencyjnymi i zgodnych z `ObservableObject`, zarządzanych przez `@StateObject` lub obserwowanych przez `@ObservedObject`.

Definiowanie ObservableObject

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

@StateObject — własność

```swift struct ShopView: View { @StateObject private var cart = CartModel() // owns the model var body: some View { CartList(cart: cart) } } ``` Używaj `@StateObject`, gdy widok tworzy model i jest jego właścicielem.

@ObservedObject — własność zewnętrzna

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

Różnica

• `@StateObject` — widok tworzy model, a model zachowuje się między ponownymi renderowaniami • `@ObservedObject` — model jest przekazywany z zewnątrz i może zostać utworzony ponownie przez rodzica Użycie `@ObservedObject` w sytuacji, gdy potrzebne jest `@StateObject`, powoduje nieoczekiwane zresetowanie modelu.

Subskrypcja objectWillChange

SwiftUI automatycznie subskrybuje `objectWillChange` podczas używania `@StateObject` lub `@ObservedObject`. Każda zmiana `@Published` powoduje ponowne renderowanie.

Ręczne objectWillChange

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

Zagnieżdżone ObservableObjects

SwiftUI nie obserwuje automatycznie zagnieżdżonych obiektów ObservableObject. Zmiany należy przekazywać ręcznie: ```swift class Parent: ObservableObject { @Published var child = ChildModel() private var cancel: AnyCancellable? init() { cancel = child.objectWillChange.sink { [weak self] _ in self?.objectWillChange.send() } } } ```

Makro @Observable (Swift 5.9)

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

Testowanie ObservableObject

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

Szybkie sprawdzenie

Kiedy należy użyć `@StateObject`, a kiedy `@ObservedObject`?

Podsumowanie

Najważniejsze informacje: • `ObservableObject` + `@Published` = reaktywny model • `@StateObject` — widok jest właścicielem modelu, który zachowuje się między ponownymi renderowaniami • `@ObservedObject` — model jest przekazywany z zewnątrz, więc ma zewnętrznego właściciela • `objectWillChange.send()` służy do ręcznego wysyłania powiadomień • Makro `@Observable` w Swift 5.9 zastępuje większość tego rozwiązania Następny temat: @EnvironmentObject.

Często zadawane pytania

Czy lekcja „@ObservableObject i @StateObject” jest bezpłatna?

Tak — pełny tekst „@ObservableObject i @StateObject” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „@ObservableObject i @StateObject”?

Tworzenie modeli typu referencyjnego sterujących widokami SwiftUI za pośrednictwem @Published. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „@ObservableObject i @StateObject”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. @Binding: dwukierunkowy przepływ danych
  2. @ObservableObject i @StateObject
  3. @EnvironmentObject dla współdzielonego stanu
  4. Pojedyncze źródło prawdy i jednokierunkowy przepływ
← Powrót do Swift Academy