Arquitectura SwiftUI
Cuándo Usar Esta Skill
Usa esta skill cuando:
- Tienes lógica en tus archivos de vista SwiftUI y quieres extraerla
- Estás eligiendo entre MVVM, TCA, los patrones nativos de SwiftUI o Coordinator
- Refactorizas vistas para separar responsabilidades
- Quieres hacer que el código SwiftUI sea testable
- Te preguntas "¿dónde debería ir este código?"
- Decides qué property wrapper usar (@State, @Environment, @Bindable)
- Organizas una base de código SwiftUI para desarrollo en equipo
Ejemplos de Prompt
| Lo Que Podrías Preguntar | Por Qué Esta Skill Ayuda |
|---|---|
| "Hay bastante código en mis archivos de vista sobre cosas de lógica. ¿Cómo lo extraigo?" | Proporciona un flujo de trabajo de refactorización con árboles de decisión sobre dónde pertenece la lógica |
| "¿Debería usar MVVM, TCA o los patrones nativos de Apple?" | Criterios de decisión basados en la complejidad de la app, tamaño del equipo, necesidades de testabilidad |
| "¿Cómo hago testable mi código SwiftUI?" | Muestra patrones de separación que permiten pruebas sin importar SwiftUI |
| "¿Dónde deberían ir los formateadores y cálculos?" | La sección de antipatrones previene la lógica en los cuerpos de las vistas |
| "¿Qué property wrapper uso?" | Árbol de decisión para @State, @Environment, @Bindable o propiedades simples |
Árbol de Decisión de Arquitectura Rápido
¿Qué impulsa tu elección de arquitectura?
│
├─ ¿Empiezas desde cero, app pequeña/mediana, quieres los patrones de Apple?
│ └─ Usa los Patrones Nativos de Apple (Parte 1)
│ - Modelos @Observable para la lógica de negocio
│ - State-as-Bridge para límites asíncronos
│ - Árbol de decisión de property wrappers
│
├─ ¿Estás familiarizado con MVVM de UIKit?
│ └─ Usa el Patrón MVVM (Parte 2)
│ - ViewModels como adaptadores de presentación
│ - Separación clara Vista/ViewModel/Modelo
│ - Funciona bien con @Observable
│
├─ ¿App compleja, necesitas testabilidad rigurosa, consistencia en el equipo?
│ └─ Considera TCA (Parte 3)
│ - Arquitectura Estado/Acción/Reducer/Store
│ - Excelente soporte para pruebas
│ - Compensación: curva de aprendizaje + boilerplate
│
└─ ¿Navegación compleja, deep linking, múltiples puntos de entrada?
└─ Añade el Patrón Coordinator (Parte 4)
- Se puede combinar con cualquiera de los anteriores
- Extrae la lógica de navegación de las vistas
- NavigationPath + objetos Coordinator
Parte 1: Patrones Nativos de Apple (iOS 26+)
Principio Central
"Un modelo de datos proporciona separación entre los datos y las vistas que interactúan con los datos. Esta separación promueve la modularidad, mejora la testabilidad y ayuda a razonar más fácilmente sobre cómo funciona la app." — Documentación para Desarrolladores de Apple
Los patrones modernos de SwiftUI de Apple (WWDC 2023-2025) se centran en:
- @Observable para modelos de datos (reemplaza ObservableObject)
- State-as-Bridge para límites asíncronos (WWDC 2025)
- Tres property wrappers: @State, @Environment, @Bindable
- Actualizaciones de UI síncronas para animaciones
El Patrón State-as-Bridge
Problema
Las funciones asíncronas crean puntos de suspensión que pueden romper las animaciones:
// ❌ Problemático: La animación podría perder el plazo del frame
struct ColorExtractorView: View {
@State private var isLoading = false
var body: some View {
Button("Extraer Colores") {
Task {
isLoading = true // Síncrono ✅
await extractColors() // ⚠️ ¡Punto de suspensión!
isLoading = false // ❌ Podría ocurrir demasiado tarde
}
}
.scaleEffect(isLoading ? 1.5 : 1.0) // ⚠️ Tiempo de animación incierto
}
}
Solución: Usa State como un Puente
"Encuentra los límites entre el código de UI que requiere cambios sensibles al tiempo y la lógica asíncrona de larga duración."
// ✅ Correcto: State une la UI y el código asíncrono
@Observable
class ColorExtractor {
var isLoading = false
var colors: [Color] = []
func extract(from image: UIImage) async {
// Este método es asíncrono y puede vivir en el modelo
let extracted = await heavyComputation(image)
// Mutación síncrona para la actualización de UI
self.colors = extracted
}
}
struct ColorExtractorView: View {
let extractor: ColorExtractor
var body: some View {
Button("Extraer Colores") {
// Cambio de estado síncrono para la animación
withAnimation {
extractor.isLoading = true
}
// Inicia el trabajo asíncrono
Task {
await extractor.extract(from: currentImage)
// Cambio de estado síncrono para la animación
withAnimation {
extractor.isLoading = false
}
}
}
.scaleEffect(extractor.isLoading ? 1.5 : 1.0)
}
}
Beneficios:
- La lógica de UI permanece síncrona (las animaciones funcionan correctamente)
- El código asíncrono vive en el modelo (testable sin SwiftUI)
- Límite claro entre UI sensible al tiempo y trabajo de larga duración
Árbol de Decisión de Property Wrappers
Solo hay 3 preguntas que responder:
¿Qué property wrapper debería usar?
│
├─ ¿Este modelo necesita ser ESTADO DE LA VISTA MISMA?
│ └─ SÍ → Usa @State
│ Ejemplos: Entradas de formulario, interruptores locales, presentaciones de hojas
│ Ciclo de vida: Gestionado por el ciclo de vida de la vista
│
├─ ¿Este modelo necesita ser parte del ENTORNO GLOBAL?
│ └─ SÍ → Usa @Environment
│ Ejemplos: Cuenta de usuario, configuración de la app, inyección de dependencias
│ Ciclo de vida: Vive a nivel de app/escena
│
├─ ¿Este modelo SOLO NECESITA BINDINGS?
│ └─ SÍ → Usa @Bindable
│ Ejemplos: Editar un modelo pasado desde el padre
│ Ligero: Solo habilita la sintaxis $ para bindings
│
└─ ¿NINGUNO DE LOS ANTERIORES?
└─ Úsalo como propiedad simple
Ejemplos: Datos inmutables, modelos propiedad del padre
Sin wrapper necesario: @Observable maneja la observación
Ejemplos
// ✅ @State — La vista es dueña del modelo
struct DonutEditor: View {
@State private var donutToAdd = Donut() // Estado propio de la vista
var body: some View {
TextField("Nombre", text: $donutToAdd.name)
}
}
// ✅ @Environment — Modelo de toda la app
struct MenuView: View {
@Environment(Account.self) private var account // Global
var body: some View {
Text("Bienvenido, \(account.userName)")
}
}
// ✅ @Bindable — Necesitas bindings a un modelo propiedad del padre
struct DonutRow: View {
@Bindable var donut: Donut // El padre es dueño
var body: some View {
TextField("Nombre", text: $donut.name) // Necesita binding
}
}
// ✅ Propiedad simple — Solo lectura
struct DonutRow: View {
let donut: Donut // El padre es dueño, no se necesita binding
var body: some View {
Text(donut.name) // Solo lectura
}
}
Patrón de Modelo @Observable
Usa @Observable para la lógica de negocio que necesita activar actualizaciones de UI:
// ✅ Modelo de dominio con lógica de negocio
@Observable
class FoodTruckModel {
var orders: [Order] = []
var donuts = Donut.all
var orderCount: Int {
orders.count // Las propiedades computadas funcionan automáticamente
}
func addDonut() {
donuts.append(Donut())
}
}
// ✅ La vista rastrea automáticamente las propiedades accedidas
struct DonutMenu: View {
let model: FoodTruckModel // ¡No se necesita wrapper!
var body: some View {
List {
Section("Donas") {
ForEach(model.donuts) { donut in
Text(donut.name) // Rastrea model.donuts
}
Button("Añadir") {
model.addDonut()
}
}
Section("Pedidos") {
Text("Conteo: \(model.orderCount)") // Rastrea model.orders
}
}
}
}
Cómo funciona (WWDC 2023/10149):
- SwiftUI rastrea qué propiedades se acceden durante la ejecución de
body - Solo esas propiedades activan actualizaciones de vista cuando cambian
- Seguimiento de dependencias granular = mejor rendimiento
Patrón de Adaptador ViewModel
Usa ViewModels como adaptadores de presentación cuando necesites filtrado, ordenamiento o lógica específica de vista:
// ✅ ViewModel como adaptador de presentación
@Observable
class PetStoreViewModel {
let petStore: PetStore // Modelo de dominio
var searchText: String = ""
// Propiedad computada específica de vista
var filteredPets: [Pet] {
guard !searchText.isEmpty else { return petStore.myPets }
return petStore.myPets.filter { $0.name.contains(searchText) }
}
}
struct PetListView: View {
@Bindable var viewModel: PetStoreViewModel
var body: some View {
List {
ForEach(viewModel.filteredPets) { pet in
PetRowView(pet: pet)
}
}
.searchable(text: $viewModel.searchText)
}
}
Cuándo usar un adaptador ViewModel:
- Filtrar, ordenar, agrupar para mostrar
- Formatear para presentación (pero NO cálculos pesados)
- Estado específico de vista que no pertenece al modelo de dominio
- Unir el modelo de dominio con las convenciones de SwiftUI
Cuándo NO usar un ViewModel:
- Vistas simples que solo muestran datos del modelo
- Lógica que pertenece al modelo de dominio
- Sobre-extracción solo por "pureza del patrón"
Parte 2: Patrón MVVM
Cuándo Usar MVVM
MVVM (Modelo-Vista-ViewModel) es apropiado cuando:
✅ Estás familiarizado con él de UIKit — Incorporación más fácil para el equipo ✅ Quieres una separación explícita Vista/ViewModel — Contratos claros ✅ Tienes lógica de presentación compleja — Múltiples operaciones de filtrado/ordenamiento ✅ Estás migrando desde UIKit — Modelo mental familiar
❌ Evita MVVM cuando:
- Las vistas son simples (solo muestran datos)
- Empiezas desde cero con SwiftUI (los patrones de Apple son más simples)
- Estás creando capas de abstracción innecesarias
Estructura MVVM para SwiftUI
// Modelo — Datos de dominio y lógica de negocio
struct Pet: Identifiable {
let id: UUID
var name: String
var kind: Kind
var trick: String
var hasAward: Bool = false
mutating func giveAward() {
hasAward = true
}
}
// ViewModel — Lógica de presentación
@Observable
class PetListViewModel {
private let petStore: PetStore
var pets: [Pet] { petStore.myPets }
var searchText: String = ""
var selectedSort: SortOption = .name
var filteredSortedPets: [Pet] {
let filtered = pets.filter { pet in
searchText.isEmpty || pet.name.contains(searchText)
}
return filtered.sorted { lhs, rhs in
switch selectedSort {
case .name: lhs.name < rhs.name
case .kind: lhs.kind.rawValue < rhs.kind.rawValue
}
}
}
init(petStore: PetStore) {
self.petStore = petStore
}
func awardPet(_ pet: Pet) {
petStore.awardPet(pet.id)
}
}
// Vista — Solo UI
struct PetListView: View {
@Bindable var viewModel: PetListViewModel
var body: some View {
List {
ForEach(viewModel.filteredSortedPets) { pet in
PetRow(pet: pet) {
viewModel.awardPet(pet)
}
}
}
.searchable(text: $viewModel.searchText)
}
}
Errores Comunes de MVVM en SwiftUI
❌ Error 1: Duplicar @Observable en Vista y ViewModel
// ❌ @State + @Observable es redundante — @State crea su propio almacenamiento
struct MyView: View {
@State private var viewModel = MyViewModel() // ❌ Wrapper redundante
}
// ✅ Pasa @Observable directamente — usa @State solo si la vista es DUEÑA del ciclo de vida
struct MyView: View {
let viewModel: MyViewModel // ✅ O @State si la vista lo crea
}
❌ Error 2: ViewModel Dios
// ❌ No hagas esto
@Observable
class AppViewModel {
// Configuración
var isDarkMode = false
var notificationsEnabled = true
// Usuario
var userName = ""
var userEmail = ""
// Contenido
var posts: [Post] = []
var comments: [Comment] = []
// ... 50 propiedades más
}
// ✅ Correcto: Separa responsabilidades
@Observable
class SettingsViewModel {
var isDarkMode = false
var notificationsEnabled = true
}
@Observable
class UserProfileViewModel {
var user: User
}
@Observable
class FeedViewModel {
var posts: [Post] = []
}
❌ Error 3: Lógica de Negocio en el ViewModel
// ❌ Las reglas de negocio pertenecen al Modelo, no al ViewModel
@Observable class OrderViewModel {
func calculateDiscount(for order: Order) -> Double { /* ... */ } // ❌ Lógica de negocio
}
// ✅ El Modelo es dueño de la lógica de negocio; el ViewModel solo formatea para mostrar
struct Order {
func calculateDiscount() -> Double { /* reglas de negocio */ }
}
@Observable class OrderViewModel {
let order: Order
var displayDiscount: String {
"$\(order.calculateDiscount(), specifier: \"%.2f\")" // ✅ Solo formateo
}
}
Parte 3: TCA (Arquitectura Componible)
Cuándo Considerar TCA
TCA es una arquitectura de terceros de Point-Free. Considérelo cuando:
✅ La testabilidad rigurosa es crítica — TestStore hace que las pruebas sean deterministas ✅ Un equipo grande necesita consistencia — Patrones estrictos reducen la variación ✅ Manejo de estado complejo — Efectos secundarios, dependencias, composición ✅ Valoras los patrones tipo Redux — Flujo de datos unidireccional
❌ Evita TCA cuando:
- App pequeña o prototipo (demasiada sobrecarga)
- El equipo no está familiarizado con la programación funcional
- Necesitas iteración rápida (el boilerplate ralentiza el desarrollo)
- Quieres dependencias mínimas
Conceptos Centrales de TCA
TCA tiene 4 bloques de construcción — Estado (datos), Acción (eventos), Reducer (evolución del estado) y Store (motor de ejecución). Aquí están en una sola característica:
// ESTADO — Datos que tu característica necesita
@ObservableState
struct CounterFeature {
var count = 0
var fact: String?
var isLoading = false
}
// ACCIÓN — Todos los eventos posibles
enum Action {
case incrementButtonTapped
case decrementButtonTapped
case factButtonTapped
case factResponse(String)
}
// REDUCER — Cómo evoluciona el estado en respuesta a las acciones
struct CounterFeature: Reducer {
@Dependency(\.continuousClock) var clock
@Dependency(\.factClient) var factClient
var body: some ReducerOf<Self> {
Reduce { state, action in
switch action {
case .incrementButtonTapped:
state.count += 1
return .none
case .decrementButtonTapped:
state.count -= 1
return .none
case .factButtonTapped:
state.isLoading = true
return .run { [count = state.count] send in
let fact = try await factClient.fetch(count)
await send(.factResponse(fact))
}
case let .factResponse(fact):
state.isLoading = false
state.fact = fact
return .none
}
}
}
}
// VISTA — Solo observa el estado y envía acciones
struct CounterView: View {
let store: StoreOf<CounterFeature>
var body: some View {
Form {
Text("\(store.count)")
HStack {
Button("-") { store.send(.decrementButtonTapped) }
Button("+") { store.send(.incrementButtonTapped) }
}
Button("Obtener Dato") { store.send(.factButtonTapped) }
if let fact = store.fact {
Text(fact)
}
}
.disabled(store.isLoading)
}
}
El Patrón Store
TCA's Store es el único lugar que ejecuta eventos:
struct App: View {
let store = Store(initialState: CounterFeature()) {
CounterFeature()
}
var body: some View {
CounterView(store: store)
}
}
Cuándo Usar Efectos (y Cuándo No)
Usa efectos para:
- Llamadas a API
- Timers, suscripciones a notificaciones
- Persistencia
- Cualquier cosa
asyncfuera del reducer
No uses efectos para:
- Sincronizar múltiples stores (usa
@Presentso composición) - Lógica de UI (gestos, animaciones — mantén en la vista)
Parte 4: Patrón Coordinator
Cuándo Usar un Coordinator
Usa un Coordinator cuando:
✅ Navegación compleja — Múltiples pantallas, flujos profundos ✅ Deep linking — Enlaces que necesitan construir una pila de navegación ✅ Múltiples puntos de entrada — Diferentes formas de llegar a la misma pantalla ✅ Pruebas — Quieres probar la lógica de navegación sin renderizar vistas
NO uses un Coordinator cuando:
- Tienes 2-3 pantallas con navegación push simple
- Navegación basada en pestañas plana
- Prototipos o apps pequeñas
Coordinator con NavigationStack
// Coordinator gestiona la navegación
@Observable
class AppCoordinator {
var path = NavigationPath()
func showDetail(for item: Item) {
path.append(DetailDestination.item(item))
}
func showSettings() {
path.append(ModalDestination.settings)
}
func handleDeepLink(_ url: URL) {
// Lógica de deep linking centralizada
switch parseDeepLink(url) {
case .item(let id):
path = NavigationPath() // Reinicia
path.append(DetailDestination.item(Item(id: id)))
case .profile:
path.append(ModalDestination.profile)
}
}
}
struct AppView: View {
@State private var coordinator = AppCoordinator()
var body: some View {
NavigationStack(path: $coordinator.path) {
HomeView(coordinator: coordinator)
.navigationDestination(for: DetailDestination.self) { dest in
switch dest {
case .item(let item): ItemDetailView(item: item)
}
}
.sheet(item: $coordinator.modalDestination) { dest in
switch dest {
case .settings: SettingsView()
case .profile: ProfileView()
}
}
}
}
}
Coordinator con Enumeraciones de Destino
// Enumera todos los destinos de navegación
enum DetailDestination: Hashable {
case item(Item)
case list([Item])
}
enum ModalDestination: Identifiable {
case settings
case profile
var id: String { "\(self)" }
}
Beneficios Clave de los Coordinators
- Navegación centralizada — No dispersa en las vistas
- Deep linking — Un lugar para analizar y manejar
- Pruebas — Prueba la lógica de navegación sin SwiftUI
- Reutilización — Cambia la navegación sin cambios en las vistas
Refactorización: Dónde Poner la Lógica
Árbol de Decisión de Colocación de Código
¿Dónde debería ir este código?
│
├─ ¿Es un cálculo o transformación de datos?
│ ├─ Sí, reglas de negocio → Modelo (@Observable)
│ └─ Sí, formato de presentación → ViewModel (si existe)
│
├─ ¿Maneja eventos de UI o navegación?
│ ├─ Gestos/animaciones → Vista (body o modifiers)
│ └─ Lógica de navegación → Coordinator
│
├─ ¿Requiere trabajo asíncrono?
│ ├─ Con actualizaciones de UI sensibles al tiempo → State-as-Bridge
│ └─ Sin sensibilidad al tiempo → Modelo (@Observable)
│
└─ ¿Es estado efímero de la vista?
└─ @State directamente en la vista
Antipatrón: Lógica en el Cuerpo de la Vista
// ❌ Antipatrón: Cálculos pesados en el cuerpo de la vista
struct OrderSummary: View {
let orders: [Order]
var body: some View {
let total = orders.reduce(0) { $0 + $1.total } // ❌ Cálculo en el cuerpo
let discount = orders.count > 5 ? 0.1 : 0.0 // ❌ Reglas de negocio
let final = total * (1 - discount) // ❌ Lógica de presentación
Text("Total: $\(final, specifier: \"%.2f\")")
}
}
// ✅ Correcto: Lógica extraída
@Observable
class OrderService {
func calculateTotal(for orders: [Order]) -> Double {
// Reglas de negocio y cálculos
}
}
struct OrderSummary: View {
let orders: [Order]
let orderService: OrderService
var body: some View {
let total = orderService.calculateTotal(for: orders)
Text("Total: $\(total, specifier: \"%.2f\")")
}
}
Modificadores y Sub-vistas
Para lógica específica de UI que es demasiado compleja para el cuerpo:
// Extrae lógica compleja de UI en un modificador
struct ListStyleModifier: ViewModifier {
@Environment(\.horizontalSizeClass) var sizeClass
func body(content: Content) -> some View {
content
.listStyle(sizeClass == .regular ? .insetGrouped : .plain)
.scrollContentBackground(.hidden)
}
}
extension View {
func adaptiveListStyle() -> some View {
modifier(ListStyleModifier())
}
}
Plantilla de Refactorización
Al refactorizar una vista, sigue estos pasos:
- Identifica la lógica que no es de UI — Cálculos, transformaciones, llamadas de red
- Clasifícala — ¿Regla de negocio, formato de presentación o estado de vista?
- Extráela — Al modelo apropiado, ViewModel o modificador
- Agrega pruebas — La lógica extraída ahora es fácil de probar
- Actualiza la vista — Solo UI y delegación
Laboratorio de Arquitectura SwiftUI
¿Qué es esto?
Esta es una práctica guiada para aplicar los patrones de arquitectura que has aprendido. Cada sección te guía en la refactorización o construcción de una característica específica.
Laboratorio 1: Refactorizar una Vista con Lógica Mezclada
Característica: Una vista de perfil de usuario que actualmente mezcla lógica de negocios, formato y UI.
// Código de inicio: Todo mezclado
struct ProfileView: View {
let user: User
@State private var isFollowing = false
var body: some View {
VStack {
// Lógica de negocios
let isPremium = user.purchaseHistory.total > 100 &&
user.subscriptionStatus == .active
// Formato
let joinedDate = user.joinDate.formatted(date: .long, time: .omitted)
let initials = user.name.components(separatedBy: " ")
.compactMap(\.first)
.map(String.init)
.joined()
// UI
Text(initials)
.font(.largeTitle)
Text(user.name)
Text("Miembro desde: \(joinedDate)")
if isPremium {
BadgeView("Premium")
}
Button(isFollowing ? "Siguiendo" : "Seguir") {
isFollowing.toggle()
}
}
}
}
Tu Tarea
Refactoriza ProfileView siguiendo estos pasos:
- Extrae la lógica de negocios (
isPremium) a un modelo - Extrae el formato a un ViewModel o computada
- Mantén solo UI en la vista
Solución
// Modelo
@Observable
class UserProfile {
let user: User
var isFollowing = false
var isPremium: Bool {
user.purchaseHistory.total > 100 &&
user.subscriptionStatus == .active
}
var formattedJoinDate: String {
user.joinDate.formatted(date: .long, time: .omitted)
}
var initials: String {
user.name.components(separatedBy: " ")
.compactMap(\.first)
.map(String.init)
.joined()
}
}
// Vista — Solo UI
struct ProfileView: View {
@Bindable var profile: UserProfile
var body: some View {
VStack {
Text(profile.initials)
.font(.largeTitle)
Text(profile.user.name)
Text("Miembro desde: \(profile.formattedJoinDate)")
if profile.isPremium {
BadgeView("Premium")
}
Button(profile.isFollowing ? "Siguiendo" : "Seguir") {
profile.isFollowing.toggle()
}
}
}
}
Trabajo Futuro
Esta skill es mantenida activamente. El trabajo futuro incluye:
- Agregar más laboratorios prácticos de refactorización
- Cubrir arquitectura de pruebas (Unit, Swift Testing, XCTest)
- Incluir más guías de PartyKit/CloudKit
- Agregar patrones de manejo de errores
- Cubrir estrategias de migración de UIKit a SwiftUI
Más Información
Para más información, contacta al mantenedor o consulta el README del proyecto.