Gestion fonctionnelle des erreurs
Mapper et récupérer
Gestion fonctionnelle des erreurs est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 4 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 Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.
Les erreurs comme flux de données
La gestion fonctionnelle des erreurs traite les failures comme des valeurs que vous pouvez transformer, enchaîner et recover, exactement comme les valeurs réussies. Le Result intégré propose précisément les opérateurs nécessaires.
map
map transforme une valeur de success et laisse une failure inchangée, en la propageant telle quelle.
fun main() {
val r = Result.success(5).map { it * 2 }
println(r.getOrNull())
val f = Result.failure<Int>(Exception("x")).map { it * 2 }
println(f.getOrNull())
}mapCatching
Si la transformation elle-même peut lancer une exception, mapCatching capture cette exception dans le résultat au lieu de la laisser s’échapper.
fun main() {
val r = Result.success("10").mapCatching { it.toInt() }
println(r.getOrNull())
val bad = Result.success("oops").mapCatching { it.toInt() }
println(bad.isFailure)
}recover
recover transforme une failure en success en calculant une valeur à partir de l’exception. Un success est transmis sans modification.
fun main() {
val r = Result.failure<Int>(Exception("down")).recover { 0 }
println(r.getOrNull())
val ok = Result.success(7).recover { 0 }
println(ok.getOrNull())
}recoverCatching
Lorsque la logique de récupération peut elle aussi échouer, recoverCatching enveloppe cette tentative et conserve l’ensemble sous forme de résultat.
fun main() {
val r = Result.failure<Int>(Exception()).recoverCatching {
"5".toInt()
}
println(r.getOrNull())
}onSuccess et onFailure
Ces fonctions exécutent des effets de bord sans modifier le résultat, qu'elles renvoient pour permettre un nouvel enchaînement. Elles sont idéales pour la journalisation.
fun main() {
runCatching { "3".toInt() }
.onSuccess { println("ok " + it) }
.onFailure { println("fail " + it.message) }
.also { println("done") }
}Enchaînement d'une chaîne de traitement
Les opérateurs se composent en une chaîne de traitement claire : capturer, transformer, récupérer, le tout sans blocs try/catch imbriqués.
fun main() {
val result = runCatching { "21".toInt() }
.map { it * 2 }
.recover { -1 }
.getOrThrow()
println(result)
}fold vers une valeur finale
Terminez une chaîne de traitement avec fold pour regrouper les deux branches en une seule valeur concrète, comme un message destiné à l'utilisateur.
fun main() {
val msg = runCatching { "x".toInt() }
.map { it + 1 }
.fold(
onSuccess = { "result: " + it },
onFailure = { "failed: " + it.message }
)
println(msg)
}Appliquer map à un type personnalisé
Vous pouvez donner à votre propre type de résultat scellé la même facilité d'utilisation en écrivant des fonctions d'extension comme map.
sealed class Res<out T> {
data class Ok<T>(val v: T) : Res<T>()
data class Err(val msg: String) : Res<Nothing>()
}
fun <T, R> Res<T>.map(f: (T) -> R): Res<R> = when (this) {
is Res.Ok -> Res.Ok(f(v))
is Res.Err -> this
}
fun main() {
val r = Res.Ok(4).map { it * 3 }
println(r)
}Pourquoi le style fonctionnel
La gestion fonctionnelle des erreurs garde le chemin nominal lisible, tandis que les erreurs circulent de manière déclarative. Les blocs try/catch ne sont pas dispersés, et le système de types suit les échecs de bout en bout.
Tout assembler
Vous disposez maintenant d'une boîte à outils complète :
map/mapCatchingpour transformerrecover/recoverCatchingpour récupéreronSuccess/onFailurepour les effetsfoldpour finaliser
Vérification rapide
Évaluez votre compréhension de la gestion fonctionnelle des erreurs.
Récapitulatif
Vous avez appris la gestion fonctionnelle des erreurs :
- Transformer avec
map/mapCatching - Récupérer avec
recover/recoverCatching - Observer avec
onSuccess/onFailure - Finaliser avec
fold
Vous avez ainsi terminé le cours sur la gestion des résultats et la modélisation des erreurs.
Questions Fréquemment Posées
La leçon « Gestion fonctionnelle des erreurs » est-elle gratuite ?
Oui — le texte complet de « Gestion fonctionnelle 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 Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Gestion fonctionnelle des erreurs » ?
Mapper et récupérer Tu pratiques Kotlin 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 Kotlin Academy ?
Aucune expérience préalable n'est requise. Kotlin 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 4 sur 4.
Combien de temps prend la leçon « Gestion fonctionnelle 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 Kotlin Academy ?
Oui. Chaque leçon Kotlin 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
- Le type Result
- runCatching
- Hiérarchies Result scellées
- Gestion fonctionnelle des erreurs