MVVM en Swift para iOS separa la interfaz, el estado de presentación y el acceso a los datos para que cada parte tenga una responsabilidad reconocible. En una pantalla de búsqueda, por ejemplo, la vista dibuja el campo y los resultados; el ViewModel procesa el texto y decide qué estado mostrar; y un servicio obtiene los datos. La separación ayuda a mantener el código cuando la pantalla crece, aunque añadir capas a una vista pequeña también puede complicarlo sin aportar valor.
MVVM significa Model-View-ViewModel. No es una función de Swift ni una arquitectura impuesta por Apple: es una forma de organizar el código que se combina con herramientas del lenguaje y de SwiftUI. Para situar este patrón entre otros enfoques de desarrollo para la plataforma, puedes consultar la sección de Swift iOS.
Qué hace cada parte de MVVM
La vista presenta y transmite acciones
La View es la interfaz que ve la persona usuaria. En SwiftUI suele ser una estructura que describe controles como textos, botones y listas. También puede reaccionar a cambios en el estado observado. Su responsabilidad principal es mostrar información y comunicar acciones —por ejemplo, que se ha escrito una consulta o se ha pulsado un botón—, no decidir cómo se consulta una API ni transformar por su cuenta toda la respuesta recibida.
El ViewModel prepara el estado de la pantalla
El ViewModel traduce las acciones de la vista a operaciones y expone un estado que la interfaz pueda representar. Puede contener la consulta, los resultados, un indicador de carga y un mensaje de error. No debería depender de elementos visuales concretos, como un componente de SwiftUI, porque su utilidad está precisamente en poder probar la lógica sin dibujar la pantalla.
El modelo y los servicios representan los datos
El término Model puede referirse a los tipos de datos del dominio, como un resultado de búsqueda, y también a la lógica relacionada con esos datos. En una aplicación real, es útil distinguir el modelo de dominio del servicio que obtiene información de una API o de una base de datos. El ViewModel coordina ese acceso, pero no tiene por qué contener la implementación de red.
Ejemplo: una búsqueda de películas
Imaginemos una pantalla que permite buscar películas. Para mantener el ejemplo centrado en la arquitectura, el servicio siguiente devuelve datos ficticios de forma asíncrona: no realiza una petición real ni incluye manejo de red. La vista podrá mostrar cuatro situaciones: estado inicial, carga, resultados y error. Tenerlas identificadas evita que la interfaz dependa de condiciones dispersas por distintos controles.
import SwiftUI
struct Pelicula: Identifiable {
let id: Int
let titulo: String
}
protocol BuscadorPeliculas {
func buscar(_ texto: String) async throws -> [Pelicula]
}
enum EstadoBusqueda {
case inicial
case cargando
case resultados([Pelicula])
case error(String)
}
@MainActor
final class BusquedaViewModel: ObservableObject {
@Published var consulta = ""
@Published private(set) var estado: EstadoBusqueda = .inicial
private let buscador: BuscadorPeliculas
init(buscador: BuscadorPeliculas) {
self.buscador = buscador
}
func buscar() async {
let texto = consulta.trimmingCharacters(in: .whitespacesAndNewlines)
guard !texto.isEmpty else {
estado = .inicial
return
}
estado = .cargando
do {
let peliculas = try await buscador.buscar(texto)
estado = .resultados(peliculas)
} catch {
estado = .error("No se ha podido completar la búsqueda.")
}
}
}
El protocolo BuscadorPeliculas marca qué necesita el ViewModel sin obligarlo a conocer la clase concreta que lo resuelve. Así, durante una prueba se le puede proporcionar una implementación de prueba con resultados preparados. @Published hace que los cambios de las propiedades observadas se comuniquen a SwiftUI, mientras que private(set) permite leer el estado desde fuera, pero deja su modificación en manos del ViewModel.
@MainActor indica que las operaciones de ese tipo se ejecutan en el actor principal, apropiado para actualizar estado que consume la interfaz. La llamada asíncrona del servicio puede suspenderse mientras espera datos; al volver, el ViewModel asigna el nuevo estado. En un servicio de red real también habría que definir cómo se decodifican las respuestas y qué errores se muestran, sin trasladar esos detalles a la vista.
Conectar el estado con una vista de SwiftUI
La vista crea o recibe el ViewModel y observa sus cambios. Una versión sencilla puede usar un botón para iniciar la búsqueda, lo que permite entender el flujo sin añadir todavía búsquedas automáticas al escribir:
struct BusquedaView: View {
@StateObject private var viewModel: BusquedaViewModel
init(buscador: BuscadorPeliculas) {
_viewModel = StateObject(
wrappedValue: BusquedaViewModel(buscador: buscador)
)
}
var body: some View {
VStack {
TextField("Título de la película", text: $viewModel.consulta)
.textFieldStyle(.roundedBorder)
Button("Buscar") {
Task { await viewModel.buscar() }
}
contenido
}
.padding()
}
@ViewBuilder
private var contenido: some View {
switch viewModel.estado {
case .inicial:
Text("Escribe un título para empezar.")
case .cargando:
ProgressView("Buscando…")
case .resultados(let peliculas):
List(peliculas) { pelicula in
Text(pelicula.titulo)
}
case .error(let mensaje):
Text(mensaje)
}
}
}
En este ejemplo, @StateObject indica que la vista mantiene y crea la instancia observable durante su ciclo de vida. Si otra parte de la aplicación crea el ViewModel y se lo pasa a una vista que solo debe observarlo, suele encajar @ObservedObject. La elección depende de quién sea responsable de conservar la instancia, no de cuál propiedad parezca más cómoda.
El enlace $viewModel.consulta permite que el campo lea y actualice la consulta. Al pulsar el botón, Task inicia el trabajo asíncrono. La vista no necesita interpretar la respuesta: observa estado y presenta la rama correspondiente. Si el estado cambia, SwiftUI vuelve a calcular la parte de la interfaz que depende de él.
Cómo evitar que el patrón se vuelva rígido
MVVM no exige crear un ViewModel para cada subvista ni mover cualquier línea de código fuera de SwiftUI. Una vista con contenido estático quizá se entienda mejor sin una capa adicional. La separación empieza a ser más útil cuando hay reglas de presentación, estados de carga y error, operaciones asíncronas o lógica que interesa probar por separado.
- No conviertas el ViewModel en un contenedor universal. Si concentra navegación, red, persistencia y reglas de negocio, divide responsabilidades en servicios o componentes con límites claros.
- Evita que la vista acceda directamente a la red. Si las peticiones se realizan en el cuerpo de la vista, cuesta controlar su ciclo de vida y probar el comportamiento sin una conexión real.
- Haz explícitos los estados relevantes. Un indicador de carga separado de los resultados puede funcionar, pero un estado enumerado reduce combinaciones incoherentes, como mostrar a la vez un error y una carga activa.
- Inyecta las dependencias. Pasar el buscador al inicializador permite sustituir la implementación real por otra preparada para pruebas, en lugar de crear una dependencia fija dentro del ViewModel.
- Controla las tareas repetidas. Si la búsqueda se lanza cada vez que cambia el texto, las respuestas pueden llegar en un orden distinto al de las consultas. Para ese comportamiento hacen falta decisiones adicionales, como cancelar la tarea anterior o descartar respuestas obsoletas.
Cuándo elegir MVVM y qué no resuelve
MVVM resulta práctico cuando una pantalla combina interacción, presentación de estados y acceso a datos, y cuando esa lógica merece pruebas propias. También facilita que la vista se concentre en SwiftUI y que el ViewModel se examine con pruebas unitarias, siempre que sus dependencias puedan sustituirse. Para una pantalla sencilla, introducir protocolos, servicios y varios tipos puede aumentar el número de archivos sin mejorar la comprensión.
El patrón tampoco decide por sí solo cómo organizar la navegación entre pantallas, dónde guardar los datos ni cómo gestionar sesiones o errores de servidor. Esas cuestiones requieren decisiones adicionales. En SwiftUI, además, las herramientas de estado disponibles cambian según el tipo de propiedad y el ciclo de vida que se necesite; por eso es importante entender quién crea y conserva cada objeto, en vez de aplicar una anotación de forma automática.
Una buena señal de que la separación funciona es poder explicar el flujo de una acción de principio a fin: la persona escribe una consulta, la vista actualiza el dato enlazado, el ViewModel valida el texto y llama al buscador, y la interfaz representa el estado resultante. Si para entender ese recorrido hay que saltar entre capas sin una responsabilidad clara, la arquitectura necesita simplificarse, no añadir más piezas.
