Unwrap und seine Verwendung in Rust

Dieser Artikel wird etwas über unwrap und seine Verwendung in Rust lehren.

unwrap in Rust

Etwas unwrap bedeutet in Rust, den folgenden Befehl abzusetzen: Gib mir das Ergebnis der Berechnung, und wenn es einen Fehler gab, Panik und stoppe das Programm. Da das Auspacken ein so unkomplizierter Prozess ist, wäre es für uns von Vorteil, den Code dafür zu demonstrieren.

Allerdings müssen wir die Typen Option und Result untersuchen, bevor wir das tun können.

Typ Option

Der Typ Option ist eine Möglichkeit, die Möglichkeit der Abwesenheit mit dem Typsystem von Rust auszudrücken. Das Codieren der Möglichkeit der Abwesenheit in das Typsystem ist entscheidend, da es den Compiler zwingt, den Programmierer zu zwingen, sich mit der Abwesenheit zu befassen.

Wenn Abwesenheit möglich ist, wird das enum mit dem Namen Option<T> aus der Bibliothek std verwendet. Es handelt sich um eine von zwei Optionen.

1. Some(T) - Ein Element vom Typ T wurde identifiziert.
2. None - Es wurde kein Element erkannt.

Diese Situationen können explizit mit match oder implizit mit unwrap behandelt werden. Implizites Handling gibt entweder das innere Element oder panics zurück.

Syntax:

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

Beispiel, um die Erweiterung des Dateinamens zu finden:

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..]),
    }
}

Ausgabe:

The extension of file is: doc

Beachten Sie, dass panic manuell mit expect angepasst werden kann, aber unwrap produziert weniger relevante Ausgaben als die explizite Handhabung. Im Beispiel unten führt die explizite Behandlung zu einem kontrollierteren Ergebnis, während die Option zur Panik bei Bedarf beibehalten wird.

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);
}

Alle Lebensmittel werden explizit mit match im obigen Code für das erste behandelt.

Alle Lebensmittel werden implizit mit unwrap für die Abschnittsfunktion behandelt. Unwrap gibt eine panic zurück, wenn es none empfängt.

Ausgabe:

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

Typ Result

Result ist eine robustere Version von Option. Im Gegensatz zu Option, das die Möglichkeit des Fehlens ausdrückt, drückt Ergebnis das Fehlerpotenzial aus.

Der Fehler wird normalerweise verwendet, um anzugeben, warum die Ausführung einer Berechnung fehlgeschlagen ist. Dies ist eine verallgemeinerte Form des Wortes Option.

Syntax:

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