Rust-Operator vereinfacht die Fehlerbehandlung

Einführung

In diesem Lab wird der ?-Operator als Möglichkeit eingeführt, um den Code bei der Verkettung von Ergebnissen sauberer zu gestalten. Er wird am Ende eines Ausdrucks verwendet, der ein Result zurückgibt, und vereinfacht den Code, indem er die Err- und Ok-Zweige automatisch behandelt. Das bereitgestellte Beispiel zeigt, wie der ?-Operator in Rust verwendet wird, um verschiedene mathematische Operationen und deren potenzielle Fehler zu behandeln.

Hinweis: Wenn das Lab keinen Dateinamen angibt, 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.

Skills Graph

?

Das Verkettieren von Ergebnissen mit match kann ziemlich unübersichtlich werden; zum Glück kann der ?-Operator verwendet werden, um die Dinge wieder in Ordnung zu bringen. ? wird am Ende eines Ausdrucks verwendet, der ein Result zurückgibt, und ist äquivalent zu einem match-Ausdruck, wobei der Err(err)-Zweig zu einem frühen return Err(From::from(err)) erweitert wird und der Ok(ok)-Zweig zu einem ok-Ausdruck erweitert wird.

mod checked {
    #[derive(Debug)]
    enum MathError {
        DivisionByZero,
        NonPositiveLogarithm,
        NegativeSquareRoot,
    }

    type MathResult = Result<f64, MathError>;

    fn div(x: f64, y: f64) -> MathResult {
        if y == 0.0 {
            Err(MathError::DivisionByZero)
        } else {
            Ok(x / y)
        }
    }

    fn sqrt(x: f64) -> MathResult {
        if x < 0.0 {
            Err(MathError::NegativeSquareRoot)
        } else {
            Ok(x.sqrt())
        }
    }

    fn ln(x: f64) -> MathResult {
        if x <= 0.0 {
            Err(MathError::NonPositiveLogarithm)
        } else {
            Ok(x.ln())
        }
    }

    // Zwischenfunktion
    fn op_(x: f64, y: f64) -> MathResult {
        // Wenn `div` "fehlschlägt", dann wird `DivisionByZero` `return`ed
        let ratio = div(x, y)?;

        // Wenn `ln` "fehlschlägt", dann wird `NonPositiveLogarithm` `return`ed
        let ln = ln(ratio)?;

        sqrt(ln)
    }

    pub fn op(x: f64, y: f64) {
        match op_(x, y) {
            Err(why) => panic!("{}", match why {
                MathError::NonPositiveLogarithm
                    => "logarithm of non-positive number",
                MathError::DivisionByZero
                    => "division by zero",
                MathError::NegativeSquareRoot
                    => "square root of negative number",
            }),
            Ok(value) => println!("{}", value),
        }
    }
}

fn main() {
    checked::op(1.0, 10.0);
}

Achten Sie darauf, die Dokumentation zu überprüfen, da es viele Methoden gibt, um Result zu map/en zu komponieren.

Zusammenfassung

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