El ecosistema de Swift ha evolucionado significativamente en los últimos años, especialmente en lo que respecta al manejo de estados reactivos. Entre las herramientas más destacadas están el protocolo ObservableObject y la macro @Observable. Aunque ambos cumplen el propósito de permitir que la interfaz de usuario reaccione a cambios en los datos, sus implementaciones y usos son diferentes.
En este artículo, exploraremos las diferencias clave entre ObservableObject y @Observable, cómo funcionan y cuándo elegir cada uno en tus proyectos.
¿Qué es ObservableObject?
El protocolo ObservableObject forma parte del framework Combine y se introdujo junto con SwiftUI. Este protocolo se utiliza para crear objetos que notifican cambios en sus datos a cualquier vista que los observe. Para que funcione correctamente, debes usar la propiedad envolvente @ObservedObject o @StateObject en las vistas, y marcar las propiedades reactivas dentro del modelo con @Published.
Ejemplo con ObservableObject:
import SwiftUI
class ViewModel: ObservableObject {
@Published var contador: Int = 0
}
struct ContenidoView: View {
@StateObject var viewModel = ViewModel()
var body: some View {
VStack {
Text("Contador: \(viewModel.contador)")
Button("Incrementar") {
viewModel.contador += 1
}
}
}
}
Características clave:
1.Basado en Combine: Requiere el framework Combine para emitir notificaciones de cambios.
2.@Published como disparador: Las propiedades deben ser marcadas con @Published para emitir cambios.
3.Uso explícito: Solo las propiedades etiquetadas explícitamente con @Published generan actualizaciones.
4.Control manual: Ofrece control granular sobre qué propiedades son reactivas.
5.Compatibilidad amplia: Disponible desde iOS 13 y versiones equivalentes en otras plataformas.
¿Qué es @Observable?
La macro @Observable, incluida en el framework Observation, es introducida en Swift 5.9 junto con iOS 17, macOS Sonoma y otras plataformas, es una solución moderna que automatiza la creación de objetos observables. Con esta macro, no es necesario implementar el protocolo ObservableObject ni usar @Published. Todas las propiedades mutables (var) dentro de un objeto marcado con @Observable se convierten automáticamente en observables, excepto las marcadas con @ObservationIgnored.
Ejemplo con @Observable:
import SwiftUI
@Observable
class ViewModel {
var contador: Int = 0
}
struct ContenidoView: View {
@StateObject var viewModel = ViewModel()
var body: some View {
VStack {
Text("Contador: \(viewModel.contador)")
Button("Incrementar") {
viewModel.contador += 1
}
}
}
}
Características clave:
1.Automatización completa: Todas las propiedades mutables son observables sin necesidad de declararlas explícitamente con @Published.
2.Independencia de Combine: No requiere el framework Combine.
3.Simplicidad: Menos configuración y menor cantidad de código repetitivo.
4.Compatibilidad limitada: Solo disponible en plataformas que soportan Swift 5.9 o superior (iOS 17, macOS Sonoma, etc.).
5.Propiedades computadas observables: Las propiedades calculadas también pueden participar en la observación si dependen de datos observables.
Ventajas y desventajas
Ventajas de ObservableObject:
•Compatible con versiones anteriores de Swift y plataformas más antiguas (iOS 13+).
•Ofrece control explícito sobre qué propiedades son observables.
•Ideal para proyectos que ya dependen de Combine.
Desventajas de ObservableObject:
•Requiere más configuración manual.
•Depende de Combine, lo que puede añadir complejidad innecesaria si solo estás usando SwiftUI.
Ventajas de @Observable:
•Automatiza completamente el manejo de estados observables.
•Simplifica el código y reduce la cantidad de declaraciones redundantes.
•No depende de Combine, lo que lo hace más ligero.
Desventajas de @Observable:
•Solo funciona en plataformas recientes (iOS 17+ y macOS Sonoma).
•Todas las propiedades mutables son observables por defecto, lo que puede ser innecesario en algunos casos.
¿Cuándo usar cada uno?
Usa ObservableObject cuando:
•Tu proyecto necesita ser compatible con versiones anteriores de iOS/macOS.
•Estás trabajando en un código heredado que ya utiliza Combine.
•Quieres un control más explícito sobre qué propiedades deben ser observables.
Usa @Observable cuando:
•Estás desarrollando un nuevo proyecto en las versiones más recientes de Swift y las plataformas compatibles.
•Buscas un enfoque más limpio y moderno para manejar la reactividad.
•Quieres evitar depender de Combine y reducir el código repetitivo.
Conclusión
Tanto ObservableObject como @Observable son herramientas efectivas para manejar la reactividad en SwiftUI. Mientras que ObservableObject es ideal para proyectos que necesitan compatibilidad con versiones más antiguas o que ya usan Combine, @Observable es una solución moderna que simplifica significativamente la implementación de objetos observables.
La elección depende del contexto de tu proyecto: si priorizas compatibilidad, usa ObservableObject. Si buscas simplicidad y estás trabajando con plataformas modernas, @Observable es el camino a seguir. ¡Ambas opciones son potentes en el contexto adecuado!
Si te ha sido útil este artículo o necesitas más información puedes dejarme un comentario. Feliz codificación!
