Gestion des erreurs en Rust : try/catch et bien plus — guide complet

Introduction : pourquoi Rust n'utilise-t-il pas try/catch ?

Dans la plupart des langages de programmation (JavaScript, Python, Java), la gestion des erreurs repose sur le mécanisme des exceptions et la construction try/catch. Cependant, cette approche est absente de Rust. À la place, les développeurs utilisent un puissant système de types qui fait des erreurs une partie de la signature de la fonction. Ce n'est pas un hasard, mais une décision architecturale réfléchie : Rust vise la prévisibilité et la sécurité à l'étape de compilation, en excluant les plantages cachés du programme.

Dans cet article, nous allons voir :

• Pourquoi Rust a abandonné try/catch ;
• Comment fonctionnent les outils principaux : Option, Result, unwrap(), expect() ;
• Ce qu'est l'opérateur ? (point d'interrogation) ;
• Quand utiliser panic! et la macro try! (obsolète) ;
• Les pratiques modernes de gestion des erreurs en Rust 2024.

1. Bases : Option et Result — deux types principaux

Le type Option : quand une valeur peut être absente

Option<T> est une énumération (enum) qui représente soit une valeur (Some(T)), soit son absence (None). Il est parfaitement adapté aux situations où une erreur au sens classique ne se produit pas, mais où le résultat peut être vide.

fn trouver_utilisateur(id: u32) -> Option<String> {    let base = vec!["Alice".to_string(), "Bob".to_string()];    if id < base.len() {        Some(base[id].clone())    } else {        None    }}

fn main() {    match trouver_utilisateur(1) {        Some(nom) => println!("Trouvé : {}", nom),        None => println!("Utilisateur non trouvé"),    }}

Le type Result : succès ou erreur

Result<T, E> est l'outil principal pour la gestion des erreurs. C'est également un enum : Ok(T) (succès) ou Err(E) (erreur).

use std::fs::File;use std::io::Read;

fn lire_fichier(chemin: &str) -> Result<String, std::io::Error> {    let mut fichier = File::open(chemin)?;    let mut contenu = String::new();    fichier.read_to_string(&mut contenu)?;    Ok(contenu)}

2. L'opérateur ? (point d'interrogation) — le remplacement de try/catch

L'opérateur ? est le moyen principal de propager les erreurs vers le haut en Rust. Il remplace les constructions match volumineuses et rend le code propre. Si le résultat est Ok, la valeur est extraite et assignée à la variable. Si c'est Err, la fonction retourne immédiatement cette erreur.

use std::fs;use std::io;

fn copier_fichier(source: &str, destination: &str) -> io::Result<()> {    let donnees = fs::read(source)?; // si erreur — sortie    fs::write(destination, &donnees)?;  // si erreur — sortie    Ok(())}

fn main() -> io::Result<()> {    copier_fichier("source.txt", "dest.txt")?;    println!("Fichier copié avec succès");    Ok(())}

Important : l'opérateur ? fonctionne uniquement dans les fonctions qui retournent Result, Option ou des types implémentant le trait FromResidual.

3. panic!, unwrap et expect — quand l'erreur est fatale

La macro panic!

panic!() provoque l'arrêt d'urgence du programme (déroulement de la pile). Il est utilisé uniquement dans les situations où la poursuite de l'exécution est impossible ou insensée : erreurs dans la logique du programme, violation d'invariants, tests.

fn division(a: i32, b: i32) -> i32 {    if b == 0 {        panic!("Division par zéro !");    }    a / b}

Les méthodes unwrap() et expect()

unwrap() est un moyen rapide d'obtenir une valeur à partir de Option ou Result. Si à l'intérieur il y a None ou Err — pro