Équivalent de l'instruction Try-Catch dans Rust

Rust est un langage de programmation qui offre un moyen plus sûr et plus fiable de développer des logiciels. Il est conçu pour éviter les erreurs courantes qui entraînent des failles de sécurité dans d’autres langues.

Le langage Rust ne prend pas en charge la gestion des exceptions, ce qui signifie qu’il n’a pas d’instruction try-catch dans Rust.

L’absence de gestion des exceptions dans Rust élimine la possibilité d’erreurs d’exécution dues à des exceptions levées à partir d’une fonction. En effet, le programme s’arrêtera au point où une erreur se produit au lieu de continuer et éventuellement de causer d’autres problèmes dans la base de code.

Cet article discutera de l’équivalent Rust d’une instruction try-catch.

Équivalent de la déclaration try-catch dans Rust

Il existe de nombreux équivalents disponibles dans Rust pour les instructions try-catch. Mais, ici, dans cet article, nous ne discuterons que de quelques équivalents les plus proches.

Utilisez le ? Opérateur à Rust

En Rust, on peut utiliser le ? opérateur pour renvoyer ou non les valeurs.

La ? L’opérateur est l’une des fonctionnalités essentielles de Rust et peut être utilisé de différentes manières. Il peut vérifier si une valeur est présente, si une valeur a été affectée à une variable ou si une expression est évaluée à vrai ou faux.

La ? L’opérateur peut également être utilisé comme alternative à l’instruction try-catch de Rust. La ? L’opérateur prend une fermeture comme paramètre.

La fermeture peut alors être appelée sans se soucier de ce qui se passera si une erreur survient lors de l’exécution.

La ? L’opérateur interceptera l’erreur et renverra la valeur de la fermeture s’il n’y a pas eu d’erreur, ou il renverra un type d’erreur avec une description de ce qui s’est mal passé s’il y en a eu une.

Exemple:

fn main() {
    let hello_tasks = || -> Result<(), HelloError> {
        hello_task_1()?;
        hello_task_2()?;
        hello_task_3()?;
        Ok(())
    };
    if let Err(_err) = hello_tasks() {
        println!("There's an error in your code, please correct it");
    }
}
enum HelloError {
    HelloTask1Error,
    HelloTask2Error,
    HelloTask3Error,
}
fn hello_task_1() -> Result<(), HelloError> {
    println!("Task No 1");
    Ok(())
}
fn hello_task_2() -> Result<(), HelloError> {
    println!("Task No 2");
    Err(HelloError::HelloTask2Error)
}
fn hello_task_3() -> Result<(), HelloError> {
    println!("task3");
    Ok(())
}

Production:

Task No 1
Task No 2
There's an error in your code, please correct it

Cliquez ici pour vérifier la démonstration en direct du code mentionné ci-dessus.