Fonction de débattre pour la gestion des erreurs en rouille
Supposons que vous ayez besoin d'une fondation en béton sur la gestion des erreurs à la rouille. Vous devez comprendre les types d'options et de résultats. Ils détiennent les bases de la débat et s'attendent à des fonctions qui sont essentielles dans la gestion des erreurs.
Voyons si nous pouvons les comprendre dans ce tutoriel.
Type d'option de rouille
Le type d'option de rouille est une énumération relativement «simple» utilisée pour fabriquer la possibilité d'absence.
Jetez un œil à la syntaxe d'option suivante:
option d'énumérationAucun,
Un peu (t),
Vous remarquerez peut-être qu'il a deux variantes: quelque chose (certains) et rien (aucun). La capacité de dire au compilateur comment gérer la possibilité d'absence est importante.
En bref, pensez au type d'option comme une boîte qui peut avoir quelque chose ou rien mais pas les deux.
Type de résultat de la rouille
Le type de résultat est également défini dans la bibliothèque standard. La syntaxe est fournie ci-dessous:
Résultat de l'énumérationOK T),
Err (e),
Il a deux variantes: ok et err. Remarquez qu'il est étroitement similaire au type d'option. C'est parce que cela fonctionne très également.
Cependant, contrairement au type d'option, le type de résultat «anticipe» la possibilité d'une erreur. Pensez-y de cette façon. Si vous effectuez une opération, il n'y a que deux choses qui peuvent se produire, soit l'opération est réussie, donc OK.
Ou l'opération échoue, et vous obtenez une erreur. Par conséquent, la variante ERR émerge. Lorsque l'opération renvoie une erreur de rouille, la variante err () appellera la panique! macro et sortie.
Mais qu'est-ce que cela a à voir avec la gestion des erreurs?
Il existe deux façons de gérer la possibilité d'absence. Le premier est une manipulation explicite à l'aide de l'opérateur de correspondance, et le suivant est une manipulation implicite avec la fonction de déballage.
L'exemple de code suivant illustre les informations fournies:
# [permettre (Dead_code)]fncheck_db (db: option)
// poignée explicite avec match
matchdb
Certains ("mysql") => println!("Serveur en cours d'exécution sur le port: 3306"),
Certains ("postgresql") => println!("Serveur en cours d'exécution sur le port: 5432"),
Certains (intérieurs) => println!("Laisse-moi vérifier ça!!!"),
Aucun => println!("Fournir une DB:"),
# [permettre (Dead_code)]
fndb (db: option)
// poignée implicite avec déballage
ifdb.un peu () == ""
// paniquez si aucun
panique!("Avorté")
fnmain ()
letmysql = some ("mysql");
LetPostgres = certains ("PostgreSQL");
Soit aucun = aucun;
check_db (mysql);
check_db (postgres);
check_db (certains ("mongodb"));
check_db (aucun);
db (certains ("mongodb"));
db (aucun);
L'exemple précédent utilise deux fonctions pour illustrer la gestion des erreurs explicites et implicites dans les valeurs non et quelques valeurs de retour.
Le premier utilise l'opérateur de correspondance pour vérifier divers cas, tandis que l'autre utilise un débit. S'il n'en reçoit aucun, la fonction panique.
Le code précédent fournit la sortie suivante:
Conclusion
Cet article passe en revue la gestion des erreurs dans le langage de programmation Rust. Ce processus comprend le déballage et s'attendre à ce que les fonctions terminent le processus. De plus, le type d'option de rouille et le type de résultat de la rouille ont été discutés. Nous espérons que vous avez trouvé cet article utile. Vérifiez d'autres articles sur les conseils Linux pour plus de conseils et d'informations.