Opérateurs de gestion des erreurs
Récupérez-vous avec catch, retry et replaceError.
Opérateurs de gestion des erreurs est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.
Les erreurs dans Combine
Les publishers de Combine possèdent un type d’échec. Lorsqu’un publisher échoue, il termine le flux : plus aucune valeur n’est émise. Pour construire des chaînes de traitement résilientes, vous avez besoin d’opérateurs capables de gérer, transformer ou récupérer les erreurs.
Le type d’échec
Chaque publisher déclare un Output et un Failure. Une chaîne de traitement ne compile que lorsque les types d’erreur correspondent, c’est pourquoi les opérateurs qui modifient les échecs sont courants.
let publisher: AnyPublisher<Data, URLError> = apiClient.request()
// Output = Data, Failure = URLErrorcatch
catch intercepte un échec et remplace le publisher en échec par un nouveau. Cela vous permet de fournir des valeurs de remplacement lorsqu’un problème survient.
apiClient.fetchUser()
.catch { error in
Just(User.guest)
}
.sink { user in
print("Got", user.name)
}
.store(in: &cancellables)replaceError
replaceError(with:) est une forme plus simple de catch : il remplace tout échec par une seule valeur de remplacement et termine l’exécution avec succès.
apiClient.fetchCount()
.replaceError(with: 0)
.sink { count in
self.badge.text = "\(count)"
}
.store(in: &cancellables)retry
retry(n) se réabonne au publisher en amont jusqu’à n fois lorsqu’il échoue. Il est idéal pour les erreurs réseau temporaires.
apiClient.fetchData()
.retry(3)
.sink(receiveCompletion: { print($0) },
receiveValue: { print($0) })
.store(in: &cancellables)Combiner retry et récupération
Un motif courant de résilience : utilisez retry plusieurs fois, puis catch pour appliquer une solution de repli si toutes les tentatives échouent.
apiClient.fetchData()
.retry(2)
.catch { _ in
Just(Data())
}
.sink { data in
self.process(data)
}
.store(in: &cancellables)mapError
mapError transforme un type d'erreur en un autre. C'est essentiel pour unifier différentes erreurs en amont en un seul type d'erreur au niveau de l'application.
enum AppError: Error { case network }
apiClient.request()
.mapError { _ in AppError.network }
.sink(receiveCompletion: { _ in }, receiveValue: { _ in })
.store(in: &cancellables)Pourquoi mapError est important
Lorsque vous combinez des producteurs, leurs types Failure doivent correspondre. mapError normalise les erreurs incompatibles afin que des opérateurs comme merge et zip puissent compiler et que votre sink gère un seul type d'erreur.
setFailureType
Certains producteurs, comme Just, ont le type d'échec Never. setFailureType(to:) fait le lien afin qu'ils puissent être combinés avec des producteurs susceptibles d'échouer.
Just(42)
.setFailureType(to: AppError.self)
.merge(with: failablePublisher)
.sink(receiveCompletion: { _ in }, receiveValue: { _ in })
.store(in: &cancellables)Gérer l'achèvement
Dans sink, la fermeture d'achèvement vous indique si le flux s'est terminé ou a échoué. Examinez-la pour réagir aux erreurs qui n'ont pas été récupérées en amont.
publisher.sink(
receiveCompletion: { completion in
if case .failure(let error) = completion {
self.showAlert(error)
}
},
receiveValue: { value in
self.update(value)
}
).store(in: &cancellables)Concevoir des flux résilients
Bonnes pratiques pour gérer les erreurs :
- Utilisez retry pour les échecs temporaires
- Utilisez la récupération ou replaceError pour les solutions de repli
- Utilisez mapError pour unifier les types d'erreurs
- Gérez toujours le cas d'échec dans
sink
Vérification rapide
Évaluez vos connaissances sur la gestion des erreurs.
Récapitulatif
Vous avez découvert les opérateurs de Combine pour gérer les erreurs :
- récupération / replaceError — fournissent des solutions de repli
- retry — effectue une nouvelle tentative en cas d'échec
- mapError / setFailureType — unifient les types d'erreurs
Ensemble, ils vous permettent de créer des flux qui se dégradent proprement au lieu de s'arrêter à la première erreur.
Questions Fréquemment Posées
La leçon « Opérateurs de gestion des erreurs » est-elle gratuite ?
Oui — le texte complet de « Opérateurs de gestion des erreurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Opérateurs de gestion des erreurs » ?
Récupérez-vous avec catch, retry et replaceError. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Swift Academy ?
Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Opérateurs de gestion des erreurs » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?
Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Transformer et combiner des flux
- Planificateurs et gestion des fils d’exécution
- Opérateurs de gestion des erreurs
- Éditeurs et abonnés personnalisés