Unwrap et ses utilisations dans Rust

Cet article vous apprendra sur unwrap et ses utilisations dans Rust.

unwrap dans Rust

Dans Rust, unwrap quelque chose signifie émettre la commande suivante : “Donnez-moi le résultat du calcul, et s’il y a eu une erreur, paniquez et arrêtez le programme.” Parce que le déballage est un processus si simple, il serait avantageux pour nous de démontrer le code correspondant.

Cependant, nous devons étudier les types Option et Result avant de pouvoir le faire.

Type Option

Le type Option est un moyen d’exprimer la possibilité d’absence en utilisant le système de type de Rust. L’encodage de la possibilité d’absence dans le système de type est crucial car il oblige le compilateur à forcer le programmeur à gérer l’absence.

Lorsque l’absence est possible, l’enum nommée Option<T> de la bibliothèque std est utilisée. Il prend la forme d’une des deux options.

1. Some(T) - Un élément de type T a été identifié.
2. None - Aucun élément n’a été détecté.

Ces situations peuvent être gérées en utilisant match explicitement ou implicitement avec unwrap. La gestion implicite renvoie soit l’élément interne, soit panics.

Syntaxe:

enum Option<T> {
    None,
    Some(T),
}

Exemple pour trouver l’extension de nom de fichier :

fn find(haystack: &str, words: char) -> Option<usize> { haystack.find(words) }
fn main() {
    let name_of_file = "file.doc";
    match find(name_of_file, '.') {
        None => println!("Extension could not be found."),
        Some(i) => println!("The extension of file is: {}", &name_of_file[i+1..]),
    }
}

Production:

The extension of file is: doc

Notez que panic peut être personnalisé manuellement avec expect, mais unwrap produit une sortie moins pertinente que la gestion explicite. Dans l’exemple ci-dessous, la gestion explicite produit un résultat plus contrôlé tout en gardant l’option de panic si nécessaire.

fn adult_man(food: Option<&str>) {
    match food {
        Some("pasta") => println!("The food does not taste right."),
        Some(inner)   => println!("{}? It could be nice.", inner),
        None          => println!("No good food? Nevertheless."),
    }
}

fn food(food: Option<&str>) {
    let interior = food.unwrap();
    if interior == "pasta" { panic!("Ummmmmm!!!!"); }

    println!("I am glad to have {}s!!!!!", interior);
}

fn main() {
    let bruschetta  = Some("Bruschetta");
    let pasta = Some("pasta");
    let void  = None;

    adult_man(bruschetta);
    adult_man(pasta);
    adult_man(void);

    let spaghetti = Some("spaghetti");
    let nothing = None;

    food(spaghetti);
    food(nothing);
}

Tous les aliments sont traités explicitement en utilisant match dans le code ci-dessus pour le premier.

Toute la nourriture est manipulée implicitement en utilisant unwrap pour la fonction section. unwrap renvoie un panic lorsqu’il reçoit none.

Production:

Bruschetta? It could be nice.
The food does not taste right.
No good food? Nevertheless.
I am glad to have spaghettis!!!!!

Type Result

Result est une version plus robuste de Option. Contrairement à Option, qui exprime la possibilité d’absence, Result exprime le potentiel d’erreur.

L’erreur est généralement utilisée pour indiquer pourquoi l’exécution d’un calcul a échoué. Il s’agit d’une forme généralisée du mot Option.

Syntaxe:

enum Result<T, E> {
    Ok(T),
    Err(E),
}