Gestion des erreurs en Kotlin : try/catch et bien plus — de A à Z

Gestion des erreurs en Kotlin : try/catch et bien plus — de A à Z

La gestion des erreurs est l'une des tâches clés de tout développeur. En Kotlin, comme dans d'autres langages modernes, il existe plusieurs approches pour gérer les situations exceptionnelles. Dans cet article, nous allons passer en revue toutes les méthodes principales : du classique try/catch aux techniques avancées utilisant Result, sealed class et Nothing. Vous apprendrez à écrire un code fiable et lisible qui gère correctement les erreurs.

1. Le bloc classique try/catch/finally

Le mécanisme de base de la gestion des exceptions en Kotlin est le bloc try/catch. Il fonctionne comme en Java, mais avec quelques améliorations. En Kotlin, try est une expression qui peut retourner une valeur.

fun parseNumber(input: String): Int? {    return try {        input.toInt()    } catch (e: NumberFormatException) {        println("Erreur d'analyse : ${e.message}")        null // retourne null en cas d'erreur    } finally {        println("Le bloc finally s'exécute toujours")    }}

fun main() {    val result = parseNumber("123abc")    println(result) // null}

Caractéristiques clés :

• try peut être utilisé comme une expression — le résultat de la dernière expression dans le bloc try ou catch devient le résultat de tout le bloc.
• Le bloc finally s'exécute dans tous les cas (même en cas d'exception ou de return).
• Kotlin n'a pas d'exceptions vérifiées (checked exceptions) comme en Java — cela simplifie le code.

Il est important de se rappeler que l'abus de try/catch rend le code moins lisible. Utilisez-le uniquement pour des situations vraiment exceptionnelles, et non pour le contrôle de flux.

2. Le type Result et l'approche fonctionnelle

Pour une gestion des erreurs plus élégante, Kotlin propose le type Result<T>. C'est une classe sealed qui peut être soit Success (avec un résultat), soit Failure (avec une exception). Il est parfaitement adapté au style fonctionnel.

import kotlin.Result

fun divide(a: Int, b: Int): Result<Int> {    return try {        Result.success(a / b)    } catch (e: ArithmeticException) {        Result.failure(e)    }}

fun main() {    val result = divide(10, 0)        // Traitement avec when    when (result) {        is Result.Success -> println("Résultat : ${result.value}")        is Result.Failure -> println("Erreur : ${result.exception.message}")    }        // Ou via des méthodes    result.onSuccess { value -> println("Succès : $value") }          .onFailure { e -> println("Échec : ${e.message}") }        // Transformation    val mapped = result.map { it * 2 } // si failure, reste failure    println(mapped)}

Avantages de Result :

• Indique explicitement que la fonction peut échouer.
• Permet des chaînes d'appels (map, flatMap, recover).
• Ne nécessite pas de try/catch dans le code appelant.

Cependant, Result n'est pas conçu pour être stocké dans des collections ou transmis à travers les frontières des coroutines — pour cela, il est préférable d'utiliser sealed class.

3. Classes sealed pour une gestion détaillée des erreurs

Lorsque vous devez traiter différents types d'erreurs de manière différente, sealed class est le choix idéal. Vous pouvez créer une hiérarchie d'erreurs et les traiter dans un when avec une couverture exhaustive.

sealed class NetworkResult<out T> {    data class Success<T>(val data: T) : NetworkResult<T>()    data class NetworkError(val code: Int, val message: String) : NetworkResult<Nothing>()    data class Timeout(val timeout