0Pricing
Kotlin Academy · Leçon

runCatching et Result<T>

Utilisez runCatching pour encapsuler les exceptions dans Result et les traiter de manière fonctionnelle.

runCatching et Result<T> est une leçon Kotlin 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 Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Result<T> en bref

Result<T> est l’enveloppe Kotlin qui représente le résultat d’une opération : soit une réussite contenant une valeur de type T, soit un échec contenant un Throwable.

Bases de runCatching

runCatching { ... } exécute le bloc et enveloppe le résultat dans un Result.

fun main() {
    val good = runCatching { 10 / 2 }
    val bad  = runCatching { 10 / 0 }
    println("good isSuccess = ${good.isSuccess}")
    println("bad isFailure  = ${bad.isFailure}")
}

Extraire la valeur

getOrNull renvoie la valeur ou null. getOrThrow relance l’exception en cas d’échec. getOrDefault renvoie une valeur de secours.

fun main() {
    val r = runCatching { "42".toInt() }
    println(r.getOrNull())          // 42
    println(r.getOrDefault(-1))    // 42
    val bad = runCatching { "x".toInt() }
    println(bad.getOrNull())       // null
    println(bad.getOrDefault(0))   // 0
}

Extraire l’exception

exceptionOrNull() renvoie l’exception en cas d’échec, ou null en cas de réussite.

fun main() {
    val r = runCatching { error("boom") }
    println(r.exceptionOrNull()?.message) // boom
}

Transformer avec map

map { value -> ... } transforme la valeur de réussite. L’échec est transmis sans modification.

fun main() {
    val r = runCatching { "10" }.map { it.toInt() * 2 }
    println(r.getOrNull()) // 20
}

mapCatching

mapCatching enveloppe la transformation dans un try/catch afin que les exceptions produites dans la lambda deviennent elles aussi des échecs.

fun main() {
    val r = runCatching { "abc" }.mapCatching { it.toInt() }
    println(r.isFailure) // true
    println(r.exceptionOrNull()?.message) // For input string: "abc"
}

recover et recoverCatching

recover { e -> fallback } transforme les échecs en réussites en calculant une valeur de récupération.

fun main() {
    val r = runCatching { "abc".toInt() }
        .recover { -1 }
    println(r.getOrNull()) // -1
}

onSuccess / onFailure

Utilisez onSuccess et onFailure pour effectuer des effets de bord sans modifier le Result.

fun main() {
    runCatching { "42".toInt() }
        .onSuccess { println("parsed: $it") }
        .onFailure { println("failed: ${it.message}") }
}

fold pour les deux chemins

fold(onSuccess, onFailure) renvoie un type unifié quelle que soit la branche — ce qui est utile pour le convertir en valeur prête pour l’interface utilisateur.

fun main() {
    val r = runCatching { "10".toInt() }
    val msg: String = r.fold(
        onSuccess = { "OK: $it" },
        onFailure = { "ERR: ${it.message}" }
    )
    println(msg)
}

Utiliser Result comme type de retour

Les fonctions peuvent renvoyer Result<T> afin de rendre la gestion des erreurs explicite au point d’appel.

fun parseInt(s: String): Result<Int> = runCatching { s.toInt() }
fun main() {
    parseInt("42").onSuccess { println("got $it") }
    parseInt("xx").onFailure { println("oops: ${it.message}") }
}

Chaîner les opérations

Combinez runCatching avec map, mapCatching et recover pour créer une chaîne fluide de traitement des erreurs.

fun fetchUserId(): Result<Int> = runCatching { 42 }
fun loadName(id: Int): String = "User-$id"
fun main() {
    val name = fetchUserId()
        .map { loadName(it) }
        .recover { "Anonymous" }
        .getOrNull()
    println(name)
}

Vérification rapide

Quel générateur exécute un bloc et enveloppe son résultat — valeur ou exception — dans un Result ?

Récapitulatif

Result<T> représente une réussite ou un échec. Créez-le avec runCatching ; transformez-le avec map/mapCatching ; récupérez-le avec recover ; observez-le avec onSuccess/onFailure ; réduisez-le avec fold. Il convient parfaitement aux chaînes explicites de traitement des erreurs.

Questions Fréquemment Posées

La leçon « runCatching et Result<T> » est-elle gratuite ?

Oui — le texte complet de « runCatching et Result<T> » 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 « runCatching et Result<T> » ?

Utilisez runCatching pour encapsuler les exceptions dans Result et les traiter de manière fonctionnelle. 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 3 sur 4.

Combien de temps prend la leçon « runCatching et Result<T> » ?

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

  1. try/catch/finally comme expression
  2. Créer des classes d’exception personnalisées
  3. runCatching et Result
  4. Relancer des exceptions et chaînage des exceptions
← Retour à Kotlin Academy