Gestion des erreurs en rouille

La gestion des erreurs est pratiquement la deuxième chose la plus courante pour un programmeur, sauf faire des erreurs, bien sûr. En tant que développeur, vous rencontrerez des scénarios où vous devez vous attendre à une erreur et créer une action si cela se produit.

Bien que le compilateur implémente la gestion des erreurs par défaut, il est bon de comprendre comment gérer les erreurs pour la logique personnalisée. La gestion des erreurs empêchera votre programme de renvoyer une sortie indésirable ou de terminer anormalement.

Explorons comment gérer les erreurs dans le langage de programmation de rouille.

Types d'erreur de rouille

Il existe deux types d'erreurs dans la rouille:

1. Erreurs récupérables
2. Erreurs irrécouvrables

Erreurs irrécouvrables

Les erreurs irrécouvrables se réfèrent aux types d'erreurs qui font mourir ou quitter un programme anormalement. Un exemple serait d'accéder à un index hors lien dans un tableau.

La rouille utilise la panique! macro pour gérer les erreurs irrécouvrables. Supposons que le compilateur rencontre la panique! macro dans votre code. Il imprime les messages spécifiés, nettoie la pile et termine le programme.

La panique! La macro est très utile lorsque vous rencontrez des erreurs à partir desquelles le programme ne peut pas récupérer.

Prenez un programme simple fourni ci-dessous qui illustre comment utiliser la macro de panique:

fn main ()
panique!("Je suis mort!!");

Une fois que vous avez exécuté le code précédent, vous devez obtenir une sortie comme indiqué ci-dessous:

Appeler la panique! provoque la sortie du programme et imprime la méthode de panique spécifiée.

Retourner une panique

Rust nous permet de retourner la source d'erreur à l'aide de la variable d'environnement Rust_backtrace. Backtracing fait référence à une liste de fonctions qui ont été appelées avant l'erreur.

Prenez l'exemple fourni ci-dessous:

fn main ()
Soit Vec = Vec![1,2,3,4,5];
println!("", Vec [5]);

Dans l'exemple précédent, nous tentons de lire un index de tableau hors limites. Cela devrait provoquer la panique et la sortie du programme.

Un exemple de sortie de sortie est fourni ci-dessous:

Comme vous pouvez le voir sur la sortie, le compilateur nous dit que nous pouvons utiliser la variable d'environnement Rust_Backtrace pour obtenir la remise entier.

Nous pouvons le faire en utilisant la commande suivante:

$ Rust_backTrace = 1 Run de cargaison

Cela devrait renvoyer la sortie du retour de retour en fonction:

Cela devrait renvoyer une sortie détaillée de la façon dont l'erreur s'est produite dans votre code. Pour une option entièrement verbeux, vous pouvez utiliser le Rust_backtrace = Full.

Erreurs récupérables

En règle générale, vous aurez rarement besoin de gérer les erreurs irrécouvrables. Pour gérer les erreurs récupérables dans la rouille, nous utilisons l'énumération du résultat, qui contient deux variantes: ok et err.

Prenons le programme simple suivant qui tente d'ouvrir un fichier:

usestd :: fs :: fichier;
fnmain ()
Laissez file = file :: open ("Bonjour.SMS");
println!(":?", déposer);

Le code précédent tente d'ouvrir un fichier inexistant. L'exécution du programme fourni ci-dessus devrait revenir comme:

ERR (OS code: 2, Kind: Notfound, Message: "Le système ne peut pas trouver le fichier spécifié.")

Cependant, nous pouvons définir l'action que nous voulons si le fichier n'existe pas. Un exemple est indiqué ci-dessous:

usestd :: fs :: fichier;
fnmain ()
Laissez file = file :: open ("Bonjour.SMS");
FILE FILE MACK
Ok (fichier) =>
println!("fichier trouvé: :?", déposer)
,
Err (_error) =>
println!("fichier introuvable")

Ici, nous utilisons l'opérateur de correspondance pour vérifier si le fichier a renvoyé une erreur ou OK. Ensuite, nous prenons les actions pour chaque cas.

Nous pouvons également utiliser la méthode attendre pour créer des spécificités de gestion des erreurs personnalisées.

Par exemple:

usestd :: fs :: fichier;
fnmain ()
Laissez file = file :: open ("Bonjour.SMS")
.attendre ("l'erreur s'est produite lors de la lecture du fichier");

La méthode attendu, qui appellera la macro de panique dans une erreur, est rencontrée lors de l'ouverture du fichier.

Fermeture

Ce tutoriel a couvert les principes fondamentaux de la gestion des erreurs dans le langage de programmation Rust. De plus, ce guide a discuté des deux types d'erreurs: erreurs récupérables et erreurs irréalisables. Nous espérons que vous avez trouvé cet article utile. Vérifiez les autres articles sur les indices Linux pour plus de conseils et d'informations.