Swift Academy · Lezione

@ObservableObject e @StateObject

Creare modelli di tipo riferimento che aggiornano le view SwiftUI tramite @Published.

@ObservableObject e @StateObject è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 4 lezioni in totale.

Benvenuto

Per gestire stati complessi condivisi tra più viste, utilizzi modelli di tipo riferimento conformi a `ObservableObject`, posseduti da `@StateObject` o osservati da `@ObservedObject`.

Definire un ObservableObject

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

@StateObject — Proprietà

```swift struct ShopView: View { @StateObject private var cart = CartModel() // owns the model var body: some View { CartList(cart: cart) } } ``` Utilizzi `@StateObject` quando la vista crea e possiede il modello.

@ObservedObject — Proprietà esterna

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

La differenza

• `@StateObject` — la vista crea il modello, che persiste tra i nuovi rendering • `@ObservedObject` — il modello viene passato alla vista e può essere ricreato dal padre Utilizzare `@ObservedObject` quando è necessario `@StateObject` causa il ripristino imprevisto del modello.

Sottoscrizione a objectWillChange

SwiftUI si sottoscrive automaticamente a `objectWillChange` quando si utilizza `@StateObject` o `@ObservedObject`. Ogni modifica a una proprietà `@Published` attiva un nuovo rendering.

objectWillChange manuale

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

ObservableObject annidati

SwiftUI non osserva automaticamente gli ObservableObject annidati. Propagare manualmente le modifiche: ```swift class Parent: ObservableObject { @Published var child = ChildModel() private var cancel: AnyCancellable? init() { cancel = child.objectWillChange.sink { [weak self] _ in self?.objectWillChange.send() } } } ```

Macro @Observable (Swift 5.9)

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

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

Verifica rapida

Quando è opportuno utilizzare `@StateObject` invece di `@ObservedObject`, o viceversa?

Riepilogo

Concetti chiave: • `ObservableObject` + `@Published` = modello reattivo • `@StateObject` — la vista possiede il modello, che persiste tra i nuovi rendering • `@ObservedObject` — il modello viene passato alla vista ed è posseduto esternamente • `objectWillChange.send()` per le notifiche manuali • La macro `@Observable` di Swift 5.9 sostituisce gran parte di questo approccio Prossimo argomento: @EnvironmentObject.

Domande Frequenti

La lezione «@ObservableObject e @StateObject» è gratuita?

Sì — il testo completo di «@ObservableObject e @StateObject» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 4 lezioni in totale.

Cosa imparerò in «@ObservableObject e @StateObject»?

Creare modelli di tipo riferimento che aggiornano le view SwiftUI tramite @Published. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «@ObservableObject e @StateObject»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

@Binding: flusso di dati bidirezionale
@ObservableObject e @StateObject
@EnvironmentObject per lo stato condiviso
Un’unica fonte di verità e flusso unidirezionale

← Torna a Swift Academy