Das Result-Typ in Rust erkunden

Einführung

In diesem Lab werden wir den Result-Typ in Rust erkunden, der eine Möglichkeit bietet, potenzielle Fehler zu behandeln, im Gegensatz zum Option-Typ, der auf das mögliche Fehlen eines Werts abzielt. Der Result-Typ kann zwei Ergebnisse haben: Ok(T) für einen erfolgreichen Abschluss mit Element T und Err(E) für einen Fehler mit Element E. Wir werden sehen, wie Result in Codebeispielen verwendet wird und wie es als Rückgabetyp der main-Funktion genutzt werden kann, um Fehler zu behandeln und eine detailliertere Fehlermeldung bereitzustellen.

Hinweis: Wenn im Lab kein Dateiname angegeben ist, können Sie einen beliebigen Dateinamen verwenden. Beispielsweise können Sie main.rs verwenden und es mit rustc main.rs &&./main kompilieren und ausführen.

Result

Result ist eine erweiterte Version des Option-Typs, der möglicherweise Fehler statt möglicherweise Fehlens beschreibt.

Das heißt, Result<T, E> kann eines von zwei Ergebnissen haben:

• Ok(T): Ein Element T wurde gefunden
• Err(E): Ein Fehler mit Element E wurde gefunden

Konventionell ist das erwartete Ergebnis Ok, während das unerwartete Ergebnis Err ist.

Wie Option hat Result viele ihm zugeordnete Methoden. unwrap(), zum Beispiel, liefert entweder das Element T oder panics. Für den Fallhandhabung gibt es viele Kombinatoren zwischen Result und Option, die überlappen.

Beim Arbeiten mit Rust werden Sie wahrscheinlich Methoden finden, die den Result-Typ zurückgeben, wie z. B. die parse()-Methode. Es ist nicht immer möglich, einen String in den anderen Typ zu parsen, daher gibt parse() ein Result, das einen möglichen Fehler angibt.

Schauen wir uns an, was passiert, wenn wir einen String erfolgreich und erfolglos parse():

fn multiply(first_number_str: &str, second_number_str: &str) -> i32 {
    // Versuchen wir, `unwrap()` zu verwenden, um die Zahl herauszubekommen. Wird es uns wehtun?
    let first_number = first_number_str.parse::<i32>().unwrap();
    let second_number = second_number_str.parse::<i32>().unwrap();
    first_number * second_number
}

fn main() {
    let twenty = multiply("10", "2");
    println!("double is {}", twenty);

    let tt = multiply("t", "2");
    println!("double is {}", tt);
}

Im erfolglosen Fall lässt parse() uns mit einem Fehler zurück, auf den unwrap() panicieren kann. Darüber hinaus beendet der panic unseren Programm und gibt eine unangenehme Fehlermeldung aus.

Um die Qualität unserer Fehlermeldung zu verbessern, sollten wir den Rückgabetyp genauer definieren und den Fehler explizit behandeln.

Verwendung von Result in main

Der Result-Typ kann auch der Rückgabetyp der main-Funktion sein, wenn er explizit angegeben wird. Typischerweise hat die main-Funktion die folgende Form:

fn main() {
    println!("Hello World!");
}

Allerdings kann main auch einen Rückgabetyp von Result haben. Wenn ein Fehler innerhalb der main-Funktion auftritt, wird ein Fehlercode zurückgegeben und eine Debug-Darstellung des Fehlers (mit dem [Debug]-Trait) ausgegeben. Im folgenden Beispiel wird ein solches Szenario gezeigt und Aspekte aus [dem folgenden Abschnitt] angesprochen.

use std::num::ParseIntError;

fn main() -> Result<(), ParseIntError> {
    let number_str = "10";
    let number = match number_str.parse::<i32>() {
        Ok(number)  => number,
        Err(e) => return Err(e),
    };
    println!("{}", number);
    Ok(())
}

Zusammenfassung

Herzlichen Glückwunsch! Sie haben das Result-Lab abgeschlossen. Sie können in LabEx weitere Labs absolvieren, um Ihre Fähigkeiten zu verbessern.