El patrón Coordinator
Centralice la lógica del flujo de navegación.
El patrón Coordinator es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 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.
El problema de la navegación
Cuando las vistas presentan o colocan otras vistas directamente, la lógica de navegación queda dispersa por toda la aplicación. Cada pantalla debe conocer la siguiente, lo que crea un acoplamiento estrecho.
El patrón Coordinator resuelve esto al extraer la navegación a objetos específicos.
¿Qué es un Coordinator?
Un Coordinator es un objeto cuya única función es gestionar el flujo de navegación. Decide cuál será la siguiente pantalla y crea los controladores de vista o las vistas que se mostrarán.
Las vistas dejan de preocuparse por el enrutamiento: solo notifican los eventos y el Coordinator decide qué hacer.
El protocolo Coordinator
La mayoría de las implementaciones comienza con un protocolo pequeño al que se ajusta cada Coordinator.
protocol Coordinator: AnyObject {
var childCoordinators: [Coordinator] { get set }
func start()
}Un Coordinator concreto
Un Coordinator concreto posee un controlador de navegación y construye la primera pantalla en start().
final class AppCoordinator: Coordinator {
var childCoordinators: [Coordinator] = []
let navigationController: UINavigationController
init(navigationController: UINavigationController) {
self.navigationController = navigationController
}
func start() {
let vc = HomeViewController()
navigationController.setViewControllers([vc], animated: false)
}
}Desacoplar las vistas del enrutamiento
La principal ventaja es que una vista ya no construye la siguiente pantalla. En su lugar, informa a su Coordinator de que ha ocurrido un evento, y el Coordinator se encarga del enrutamiento.
Esto permite reutilizar una pantalla en distintos flujos sin modificar su código.
Enviar eventos hacia arriba
Las vistas se comunican con su Coordinator mediante un delegate o un closure. La vista no sabe adónde debe dirigirse después.
protocol HomeViewControllerDelegate: AnyObject {
func homeDidSelectProfile()
}
final class HomeViewController: UIViewController {
weak var delegate: HomeViewControllerDelegate?
func profileTapped() {
delegate?.homeDidSelectProfile()
}
}Gestionar la ruta
El Coordinator se ajusta al delegate y decide cómo navegar cuando se produce el evento.
extension AppCoordinator: HomeViewControllerDelegate {
func homeDidSelectProfile() {
let profile = ProfileViewController()
navigationController.pushViewController(profile, animated: true)
}
}Coordinators secundarios
Los flujos grandes (onboarding, checkout) tienen sus propios coordinators secundarios. El padre inicia un secundario y lo conserva en childCoordinators para que siga activo.
func startOnboarding() {
let child = OnboardingCoordinator(navigationController: navigationController)
childCoordinators.append(child)
child.start()
}Evitar fugas de memoria
Como el padre conserva a los secundarios, debe eliminar un secundario cuando termina su flujo; de lo contrario, se producirá una fuga de memoria. Un enfoque habitual es usar un callback de finalización.
func childDidFinish(_ child: Coordinator) {
childCoordinators.removeAll { $0 === child }
}Coordinators con SwiftUI
En SwiftUI, los Coordinators suelen controlar una ruta de NavigationStack. El Coordinator posee una ruta observable y las vistas le añaden rutas.
final class Router: ObservableObject {
@Published var path: [Route] = []
func push(_ route: Route) {
path.append(route)
}
}
enum Route: Hashable { case profile, settings }Resumen de ventajas
El patrón Coordinator proporciona:
- Vistas reutilizables que no incluyen la navegación de forma rígida
- Lógica de flujo centralizada que es fácil de modificar
- Enrutamiento comprobable separado de la interfaz de usuario
- Flujos componibles mediante coordinators secundarios
Comprobación rápida
Compruebe cuánto ha entendido sobre los Coordinators.
Resumen
Ha aprendido el patrón Coordinator:
- Los Coordinators controlan la navegación, de modo que las vistas no dependen del enrutamiento
- Las vistas envían los eventos hacia arriba mediante delegates o closures
- Los coordinators secundarios representan flujos independientes y autocontenidos
- Debe eliminar los secundarios cuando terminan los flujos para evitar fugas de memoria
Combinados con MVVM, los Coordinators completan una arquitectura limpia y fácil de probar.
Preguntas frecuentes
¿La lección «El patrón Coordinator» es gratis?
Sí — el texto completo de «El patrón Coordinator» 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 «El patrón Coordinator»?
Centralice la lógica del flujo de navegación. 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 3 de 4.
¿Cuánto tiempo toma la lección «El patrón Coordinator»?
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
- El patrón MVVM
- Vincular modelos de vista con vistas
- El patrón Coordinator
- Probar modelos de vista