Fehlerbehandlung und der ?-Operator

Die Rust-Philosophie empfiehlt, die Möglichkeit von Fehlern explizit zu erkennen und den Code so zu strukturieren, dass er damit umgeht, bevor das Programm kompiliert wird.

Fehler in Rust werden in zwei Hauptkategorien unterteilt: nicht behebbare Fehler (verursacht sofortiges Hängenbleiben über die panic!-Panik) und behebbare Fehler (behandelt über den Typ Result<T, E>).

Der Ergebnistyp<T, E> und der Mustervergleich

Die meisten behebbaren Fehler geben einen Typ Result<T, E> zurück, der eine Aufzählung ist, die wie folgt definiert ist:

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

Wir können den Mustervergleich verwenden, um das Ergebnis zu überprüfen:

use std::fs::File;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => panic!("Problema nell'aprire il file: {:?}", error),
    };
}

Fehlerausbreitung mit dem Operator ?

Wenn wir eine Funktion implementieren, möchten wir den Fehler oft nicht direkt darin behandeln, sondern den Fehler an den Aufrufer zurückgeben, damit er entscheiden kann, was zu tun ist. Dieser Vorgang wird Fehlerausbreitung genannt.

Rust stellt den Operator ? als syntaktische Abkürzung für die Fehlerausbreitung bereit. Wenn der Wert eines Result Ok ist, wird der Wert innerhalb von Ok vom Ausdruck zurückgegeben; Wenn es Err ist, wird der Fehler Err von der gesamten aktuellen Funktion zurückgegeben, als ob wir einen return Err(...) verwendet hätten.

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username_file = File::open("username.txt")?;
    let mut username = String::new();
    username_file.read_to_string(&mut username)?;
    Ok(username)
}

[!IMPORTANT] Der Operator ? kann nur in Funktionen verwendet werden, die einen Typ zurückgeben, der mit dem Wert kompatibel ist, auf den er angewendet wird (typischerweise Result, Option oder Typen, die FromResidual implementieren).

Benutzerdefinierte Fehler

Wir können unsere eigenen Fehlertypen definieren, indem wir das Merkmal std::fmt::Display (und optional std::error::Error) implementieren, um eine für Menschen lesbare Darstellung des Fehlers bereitzustellen:

use std::fmt;

#[derive(Debug)]
struct MyError {
    details: String,
}

impl fmt::Display for MyError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Errore: {}", self.details)
    }
}

impl std::error::Error for MyError {}

Probieren Sie es selbst aus

Übung 1: Eine Datei mit dem ? lesen Operator

Übung 2: Eine Zahl analysieren und verarbeiten

Übung 3: Definieren Sie einen benutzerdefinierten Fehler