Operadores de gestión de errores
Recupérese con catch, retry y replaceError.
Operadores de gestión de errores 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.
Errores en Combine
Los publishers de Combine tienen un tipo Failure. Cuando un publisher falla, termina el flujo y no se emiten más valores. Para crear pipelines resistentes, necesita operadores que gestionen, transformen o recuperen los errores.
El tipo Failure
Cada publisher declara un Output y un Failure. Una pipeline solo compila cuando los tipos de error coinciden, por lo que son habituales los operadores que modifican los errores.
let publisher: AnyPublisher<Data, URLError> = apiClient.request()
// Output = Data, Failure = URLErrorcatch
catch intercepta un error y sustituye el publisher que ha fallado por uno nuevo. Esto permite proporcionar valores alternativos cuando algo sale mal.
apiClient.fetchUser()
.catch { error in
Just(User.guest)
}
.sink { user in
print("Got", user.name)
}
.store(in: &cancellables)replaceError
replaceError(with:) es una forma más sencilla de catch: sustituye cualquier error por un único valor alternativo y finaliza correctamente.
apiClient.fetchCount()
.replaceError(with: 0)
.sink { count in
self.badge.text = "\(count)"
}
.store(in: &cancellables)retry
retry(n) vuelve a suscribirse al flujo upstream hasta n veces cuando falla. Es ideal para errores de red transitorios.
apiClient.fetchData()
.retry(3)
.sink(receiveCompletion: { print($0) },
receiveValue: { print($0) })
.store(in: &cancellables)Combinar retry y catch
Un patrón habitual de resiliencia: use retry varias veces y después catch para recurrir a una alternativa si todos los intentos fallan.
apiClient.fetchData()
.retry(2)
.catch { _ in
Just(Data())
}
.sink { data in
self.process(data)
}
.store(in: &cancellables)mapError
mapError transforma un tipo de error en otro. Esto es esencial para unificar distintos errores procedentes de servicios ascendentes en un único tipo de error de la aplicación.
enum AppError: Error { case network }
apiClient.request()
.mapError { _ in AppError.network }
.sink(receiveCompletion: { _ in }, receiveValue: { _ in })
.store(in: &cancellables)Por qué es importante mapError
Al combinar publishers, sus tipos Failure deben coincidir. mapError normaliza los errores incompatibles para que operadores como merge y zip se compilen correctamente y para que su sink gestione un único tipo de error.
setFailureType
Algunos publishers, como Just, tienen el tipo de error Never. setFailureType(to:) sirve de puente para que puedan combinarse con publishers que pueden fallar.
Just(42)
.setFailureType(to: AppError.self)
.merge(with: failablePublisher)
.sink(receiveCompletion: { _ in }, receiveValue: { _ in })
.store(in: &cancellables)Gestión de la finalización
En sink, el closure de finalización le indica si el flujo terminó correctamente o falló. Inspecciónelo para reaccionar ante los errores que no se hayan recuperado en etapas anteriores.
publisher.sink(
receiveCompletion: { completion in
if case .failure(let error) = completion {
self.showAlert(error)
}
},
receiveValue: { value in
self.update(value)
}
).store(in: &cancellables)Diseño de pipelines resilientes
Prácticas recomendadas para gestionar errores:
- Use retry para errores transitorios
- Use catch o replaceError para proporcionar alternativas
- Use mapError para unificar los tipos de error
- Gestione siempre el caso de error en
sink
Comprobación rápida
Compruebe sus conocimientos sobre la gestión de errores.
Resumen
Ha aprendido los operadores de Combine para gestionar errores:
- catch / replaceError — proporcionan alternativas
- retry — vuelve a intentar la operación cuando se produce un error
- mapError / setFailureType — unifican los tipos de error
En conjunto, le permiten crear pipelines que se degraden de forma controlada en lugar de detenerse ante el primer error.
Preguntas frecuentes
¿La lección «Operadores de gestión de errores» es gratis?
Sí — el texto completo de «Operadores de gestión de errores» 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 «Operadores de gestión de errores»?
Recupérese con catch, retry y replaceError. 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 «Operadores de gestión de errores»?
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
- Transformar y combinar flujos
- Planificadores y subprocesos
- Operadores de gestión de errores
- Publishers y Subscribers personalizados