Gestion des erreurs Rust

Rust adopte un mécanisme unique de gestion des erreurs,sans exceptions ni try/catch.Il divise les erreurs en deux catégories et les traite de différentes manières :

  • Erreurs irrécupérables(Irrécupérables) : lorsqu'il y a un problème grave dans la logique du programme, utilisez lapanic!macro `panic!` pour terminer le programme.
  • Erreurs récupérables(Récupérables) : les opérations peuvent échouer mais peuvent être gérées, en utilisant l'Result<T, E>énumération `Result<T, E>`.

Cette conception force les développeurs à gérer les erreurs possibles au moment de la compilation, plutôt que de découvrir des omissions à l'exécution.

Rust Error Handling Mechanism Overview Errors in Programs Unrecoverable errors panic!("serious error") Print error message → Unwind call stack → Terminate program Examples: array out of bounds, division by zero, logic bugs → Similar to uncaught exceptions in other languages Recoverable errors Result<T, E> Ok(T) represents success, Err(E) represents failure Examples: file not found, network timeout, parsing failure → Similar to checked exceptions in other languages

1. Erreurs irrécupérables : panic!

panic!La macro `panic!` est utilisée pour indiquer que le programme a rencontré une erreur grave qui l'empêche de continuer. Lorsqu'elle est invoquée, elle va :

  1. Afficher le message d'erreur et l'endroit où il s'est produit
  2. Dérouler la pile d'appels et nettoyer les ressources
  3. Terminer le programme

Exemple

fn main() {
    panic!("Une erreur grave s'est produite");
    // Le code suivant ne sera jamais exécuté
    println!("Bonjour, Rust");
}

Sortie :

thread 'main' panicked at '发生了严重错误', src/main.rs:2:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

La sortie comporte deux lignes d'informations :

  • First line: l'emplacement du panic (nom du fichier et numéro de ligne) et le message d'erreur
  • Second line: une indication sur la façon d'afficher la trace complète de la pile d'appels

Affichage de la trace de la pile d'appels

Définissez l'RUST_BACKTRACE=1La variable d'environnement `RUST_BACKTRACE` pour voir la pile d'appels complète, ce qui aide à localiser la cause racine du panic :

# Linux / macOS
RUST_BACKTRACE=1 cargo run

# Windows PowerShell
$env:RUST_BACKTRACE=1; cargo run

La sortie de la trace de pile listera la chaîne d'appels complète depuis l'emplacement du panic jusqu'àmainfonction `main`. Cette information est très utile lorsqu'une panique se produit dans un appel profond.

Quand l'utiliserpanic!:Il y a des erreurs logiques (bugs) dans le code qui ne devraient pas se produire, comme un accès hors limites, le déréférencement d'un pointeur nul, ou la violation d'un contrat immuable. Pour les erreurs prévisibles causées par une entrée externe, vous devez utiliser `Result<T, E>`.Result。


2. Erreurs récupérables : Result<T, E>

Result`Result<T, E>` est l'énumération de la bibliothèque standard de Rust utilisée pour représenter les opérations qui peuvent échouer :

enum Result&lt;T, E&gt; {
    Ok(T),    // 操作成功,包含结果值
    Err(E),   // 操作失败,包含错误信息
}

Toutes les fonctions de la bibliothèque standard de Rust qui peuvent échouer renvoient `Result<T, E>`.ResultPar exemple, l'ouverture d'un fichier :

`File::open()` returns `Result<File, io::Error>` let f = File::open("hello.txt"); File exists Ok(file) Gets a `File` object, which can be read from and written to File does not exist Err(io::Error) Gets error information, which can be handled

2.1 Utilisation de match pour gérer Result

Exemple

use std::fs::File;

fn main() {
    let f = File::open("hello.txt");

    correspondance f {
        Ok(file) => {
            println!("File opened successfully: {:?}", file);
        }
        Err(error) => {
            println!("Impossible d'ouvrir le fichier : {}", error);
        }
    }
}

2.2 Utilisation de if let pour une gestion simplifiée

Lorsque seul le cas de succès vous intéresse,if letComparermatch`if let` est plus concis :

Exemple

use std::fs::File;

fn main() {
    let f = File::open("hello.txt");

    if let Ok(file) = f {
        println!("Fichier ouvert avec succès");
        // Utiliser le fichier ici ...
    } else {
        println!("Impossible d'ouvrir le fichier");
    }
}

2.3 unwrap et expect : rapides mais dangereux

Si vous êtes sûr que l'opération ne va pas échouer (ou que vous ne voulez pas gérer les erreurs pendant le prototypage), vous pouvez utiliser ces deux méthodes raccourcies :

Méthode Comportement Message de panic en cas d'échec
.unwrap() En cas de succès, retourne la valeur ; en cas d'échec, elle directementTpaniquepanic! en utilisant le message d'erreur par défaut.
.expect("msg") En cas de succès, retourne la valeur ; en cas d'échec, elle directementTpaniquepanic! en utilisant un message d'erreur personnalisé (plus facile à déboguer).

Exemple

use std::fs::File;

fn main() {
    // unwrap : panique en cas d'échec, utilise le message par défaut
    // le thread 'main' a paniqué à 'appel de `Result::unwrap()` sur une valeur `Err` : ...'
    let f1 = File::open("hello.txt").unwrap();

    // expect : panique en cas d'échec, utilise un message personnalisé (recommandé)
    // le thread 'main' a paniqué à 'Failed to open config file: ...'
    let f2 = File::open("hello.txt").expect("Failed to open config file");
}

Recommandation :Dans le code de production, préférez utiliser `expect`expectplutôt que `unwrap`,unwrapcar un message d'erreur personnalisé vous aide à localiser rapidement le problème lorsqu'une panique se produit. Une approche encore meilleure consiste à utiliser l'?Opérateur `?` pour propager l'erreur à l'appelant.


3. Propagation des erreurs : l'opérateur ?

En développement réel, lorsqu'une fonction rencontre une erreur, elle ne veut souvent pas la gérer elle-même, mais veut plutôtpropagerl'erreur à l'appelant. Rust fournit?l'opérateur `?` pour simplifier cela.

3.1 Propagation manuelle vs l'opérateur ?

Tout d'abord, jetez un œil à la propagation manuelle — verbeuse mais claire :

Exemple

use std::fs::File;
use std::io::{self, Read};

// Propagation manuelle des erreurs (fastidieux)
fn read_file_manual(path: &str) -> Result<String, io::Error> {
    let f = File::open(path);

    // Retourner Err si l'ouverture échoue
    let mut file = match f {
        Ok(file) => file,
        Err(e) => return Err(e),  // Renvoyer l'erreur tôt
    };

    let mut content = String::new();

    // Renvoyer Err si la lecture échoue
    match file.read_to_string(&mut content) {
        Ok(_) => Ok(content),
        Err(e) => Err(e),
    }
}

En utilisant la?opérateur `?`, la même logique peut être simplifiée en :

Exemple

use std::fs::File;
use std::io::{self, Read};

// Utilisation de l'opérateur ? (concis)
fn read_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;   // Renvoie automatiquement Err en cas d'échec
    let mut content = String::new();
    file.read_to_string(&mut content)?; // Renvoie automatiquement Err en cas d'échec
    Ok(content)
}

Vous pouvez également enchaîner les appels pour simplifier davantage :

fn read_file(path: &str) -> Result&lt;String, io::Error&gt; {
    let mut content = String::new();
    File::open(path)?.read_to_string(&mut content)?;
    Ok(content)
}

?Comment fonctionne l'opérateur `?` :

Workflow of the ? operator let val = some_operation()?; Ok or Err? Result Ok `val` = value inside `Ok` Continue executing the subsequent code Err `return Err(e)` returns early

Limitation importante :?L'opérateur `?` ne peut être utilisé que dans les fonctions qui renvoientResult`Result` (ouOption`Option`). Depuis Rust 1.39,mainla fonction `main` peut aussi renvoyer un `Result`.Result。

3.2 Utilisation de ? dans main

Par défaut, lemainLa fonction `main` retourne()`()`, donc `?` ne peut pas être utilisé.?Mais vous pouvez faire en sorte quemain`main` retourne un `Result`.Result:

Exemple

use std::fs::File;
use std::io::{self, Read};

fn read_file(path: &str) -> Result<String, io::Error> {
    let mut content = String::new();
    File::open(path)?.read_to_string(&mut content)?;
    Ok(content)
}

// main retourne un Result, donc ? peut être utilisé dans main
fn main() -> Result<(), Box<dyn std::error::Erreur>> {
    let content = read_file("hello.txt")?;  // ? peut aussi être utilisé dans main maintenant
    println!("{}", content);
    OK(())
}

4. Types d'erreurs personnalisés et gestion catégorisée

Dans les projets réels, vous avez généralement besoin que différents types d'erreurs soient traités différemment. Rust y parvient grâce à lakind()méthode `kind()` :

Exemple

use std::fs::File;
use std::io::{self, Read};

// Encapsuler la lecture de fichier dans une fonction distincte et propager les erreurs avec ?
fn read_text_from_file(path: &str) -> Result<String, io::Error> {
    let mut f = File::open(path)?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    OK(s)
}

fn main() {
    match read_text_from_file("hello.txt") {
        Ok(content) => println!("Contenu du fichier : "\n{}", content),
        Err(e) => {
            // Gérer différents cas selon le type d'erreur
            match e.kind() {
                io::ErrorKind::NotFound => {
                    println!("Fichier introuvable, veuillez vérifier le chemin");
                }
                io::ErrorKind::PermissionDenied => {
                    println!("Aucune autorisation de lire le fichier");
                }
                _ => {
                    println!("Une erreur s'est produite lors de la lecture du fichier : {}", e);
                }
            }
        }
    }
}

Sortie (lorsque le fichier n'existe pas) :

File does not exist, please check the path.

io::ErrorKindVariantes courantes :

ErrorKind Signification
NotFound Le fichier ou le répertoire n'existe pas
PermissionDenied Autorisations insuffisantes
AlreadyExists Le fichier existe déjà (lors de la création)
ConnectionRefused Connexion refusée
TimedOut Délai d'attente de l'opération dépassé
InvalidInput Paramètre non valide

5. Types d'erreurs personnalisés

Dans les projets, vous devez généralement définir vos propres types d'erreurs pour représenter les erreurs dans la logique métier :

Exemple

use std::fmt;
use std::num::ParseIntError;

// Définir une énumération d'erreur personnalisée
#[derive(Debug)]
enum AppError {
    IoError(std::io::Error),
    ParseError(ParseIntError),
    CustomError(String),
}

// Implémenter le trait Display pour la sortie formatée
impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::IoError(e) => write!(f, "Erreur d'E/S : {}", e),
            AppError::ParseError(e) => write!(f, "Erreur d'analyse : {}", e),
            AppError::CustomError(msg) => write!(f, "Erreur métier : {}", msg),
        }
    }
}

// Implémenter le trait From afin que l'opérateur ? convertisse automatiquement les types d'erreur
impl From<std::io::Error> for AppError {
    fn from(error: std::io::Error) -> Self {
        AppError::IoError(error)
    }
}

impl From<ParseIntError> for AppError {
    fn from(error: ParseIntError) -> Self {
        AppError::ParseError(error)
    }
}

// Maintenant, vous pouvez utiliser ? dans la même fonction pour gérer différents types d'erreurs
fn process_config(path: &str) -> Result<i32, AppError> {
    let content = std::fs::read_to_string(path)?; // io::Error → AppError
    let value: i32 = content.trim().parse()?;      // ParseIntError → AppError

    if value < 0 {
        return Err(AppError::CustomError("La valeur de configuration ne peut pas être négative".into()));
    }

    Ok(value)
}

fn main() {
    match process_config("config.txt") {
        Ok(val) => println!("Valeur de configuration : {}", val),
        Err(e) => println!("Erreur : {}", e),
    }
}

Bibliothèques tierces recommandées :Dans de vrais projets, vous pouvez utiliserthiserrorla bibliothèque pour dériver automatiquementDisplayetFromles implémentations, ce qui réduit considérablement le code répétitif. Pour le code de la couche application,anyhowla bibliothèque fournit desanyhow::Resulttypes pratiques, adaptés au développement rapide.


6. Option<T> : une valeur qui peut ne pas exister

Par ailleursResult", Rust dispose également d'une autre énumération importante pour gérer le cas où la \"valeur peut ne pas exister\" —"Option<T>:

enum Option&lt;T&gt; {
    Some(T),  // 有值
    None,     // 没有值
}

Optionutilisé pour remplacer `null` dans d'autres langagesnull". Rust n'a pas de `null`,"null", toute valeur qui peut être vide doit être"Option"encapsulée dans `Option` :"

Exemple

fn find_user(id: u32) -> Option<String> {
    match id {
        1 => Some("Alice".to_string()),
        2 => Some("Bob".to_string()),
        _ => None, // L'utilisateur n'existe pas
    }
}

fn main() {
    // Utiliser match pour gérer Option
    match find_user(1) {
        Some(name) => println!("Utilisateur trouvé : {}", name),
        None => println!("L'utilisateur n'existe pas"),
    }

    // Utiliser if let pour simplifier
    if let Some(name) = find_user(99) {
        println!("Utilisateur trouvé : {}", name);
    } else {
        println!("L'utilisateur n'existe pas");
    }

    // unwrap_or fournit une valeur par défaut
    let name = find_user(99).unwrap_or("Utilisateur anonyme".to_string());
    println!("Nom d'utilisateur : {}", name);  // Utilisateur anonyme

    // L'opérateur ? fonctionne aussi avec Option
    let first_char = get_first_char("hello");
    println!("Première lettre : {:?}", first_char);  // Some('h')
}

fn get_first_char(s: &str) -> Option<char> {
    s.chars().next() // Renvoie Option<char>
}

OptionetResultComparaison :

Élément de comparaison Option<T> Result<T, E>
Objectif La valeur peut exister ou ne pas exister L'opération peut réussir ou échouer
Succès Some(T) Ok(T)
Failure None(aucune information supplémentaire) Err(E)(contient la raison de l'erreur)
Scénarios typiques Recherche, champs optionnels, valeurs par défaut Opérations sur les fichiers, requêtes réseau, analyse syntaxique
Conversion ok_or(err) → Result ok() → Option

Résumé

Scénario Approche recommandée Description
Le programme rencontre un bug irrécupérable panic!("原因") Terminer le programme, pour les situations qui ne devraient pas se produire
L'opération peut échouer RetourResult<T, E> Forcer l'appelant à gérer les erreurs
Propager les erreurs au sein d'une fonction ?operator Renvoyer automatiquement Err en cas d'échec, extraire la valeur en cas de succès
Prototypage rapide / tests .expect("原因") Panic en cas d'échec, mais avec un message d'erreur clair
La valeur peut ne pas exister Option<T> useSome / NoneRemplace null
Gérer séparément selon le type d'erreur e.kind() Faire correspondre des variantes d'erreur spécifiques
Types d'erreur personnalisés ImplémenterDisplay + From Avec?Implémenter la conversion automatique

La philosophie de gestion des erreurs de Rust :Les erreurs font partie du système de types, et non des exceptions dans le flux de contrôle. Le compilateur vous force à gérer chaque cas d'erreur possible, ce qui rend votre programme plus fiable à l'exécution.

Autres extensions