Swift Academy · Lección

@ObservableObject y @StateObject

Cree modelos de tipo referencia que impulsen las vistas de SwiftUI mediante @Published.

@ObservableObject y @StateObject es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Introducción

Para estados complejos compartidos entre varias vistas, utilice modelos de tipo referencia que adopten `ObservableObject`, sean propiedad de `@StateObject` o estén observados mediante `@ObservedObject`.

Definir un ObservableObject

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

@StateObject — propiedad

```swift struct ShopView: View { @StateObject private var cart = CartModel() // owns the model var body: some View { CartList(cart: cart) } } ``` Utilice `@StateObject` cuando la vista cree y sea propietaria del modelo.

@ObservedObject — propiedad externa

```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 diferencia

• `@StateObject` — la vista crea el modelo; este persiste entre las nuevas representaciones • `@ObservedObject` — el modelo se proporciona desde fuera; el elemento padre puede volver a crearlo Utilizar `@ObservedObject` cuando se necesita `@StateObject` hace que el modelo se restablezca inesperadamente.

Suscripción a objectWillChange

SwiftUI se suscribe automáticamente a `objectWillChange` al utilizar `@StateObject` o `@ObservedObject`. Cada cambio en `@Published` activa una nueva representación.

objectWillChange manual

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

ObservableObjects anidados

SwiftUI no observa automáticamente los ObservableObjects anidados. Reenvíe los cambios manualmente: ```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 ```

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

Comprobación rápida

¿Cuándo debe utilizar `@StateObject` en lugar de `@ObservedObject`?

Resumen

Puntos clave: • `ObservableObject` + `@Published` = modelo reactivo • `@StateObject` — la vista es propietaria del modelo; este persiste entre las nuevas representaciones • `@ObservedObject` — el modelo se proporciona desde fuera; tiene propiedad externa • `objectWillChange.send()` para las notificaciones manuales • La macro `@Observable` de Swift 5.9 reemplaza la mayor parte de este mecanismo Siguiente: @EnvironmentObject.

Preguntas frecuentes

¿La lección «@ObservableObject y @StateObject» es gratis?

Sí — el texto completo de «@ObservableObject y @StateObject» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «@ObservableObject y @StateObject»?

Cree modelos de tipo referencia que impulsen las vistas de SwiftUI mediante @Published. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «@ObservableObject y @StateObject»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

@Binding: flujo de datos bidireccional
@ObservableObject y @StateObject
@EnvironmentObject para el estado compartido
Fuente única de la verdad y flujo unidireccional

← Volver a Swift Academy