Obsługa błędów i operator ?

Filozofia Rusta zachęca do jawnego rozpoznawania możliwości wystąpienia błędów i konstruowania kodu tak, aby obsługiwał je przed skompilowaniem programu.

Błędy w Rust są podzielone na dwie główne kategorie: błędy nienaprawialne (powodujące natychmiastowe zawieszenie poprzez panikę panic!) i błędy naprawialne (obsługiwane przez typ Result<T, E>).

Typ wyniku<T, E> i dopasowanie wzorca

Większość możliwych do naprawienia błędów zwraca typ Result<T, E>, który jest wyliczeniem zdefiniowanym jako:

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

Możemy użyć dopasowywania wzorców, aby sprawdzić wynik:

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

Propagacja błędów za pomocą operatora ?

Kiedy implementujemy funkcję, zamiast bezpośrednio w niej obsługiwać błąd, często chcemy zwrócić błąd osobie wywołującej, aby mógł zdecydować, co zrobić. Proces ten nazywany jest propagacją błędów.

Rust udostępnia operator ? jako skrót składniowy do propagacji błędów. Jeśli wartość Result wynosi Ok, wartość w obrębie Ok jest zwracana przez wyrażenie; jeśli jest to Err, cała bieżąca funkcja zwraca błąd Err, tak jakbyśmy użyli return Err(...).

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

[!WAŻNE] Operatora ? można używać tylko w funkcjach zwracających typ zgodny z wartością, do której jest zastosowany (zwykle Result, Option lub typy implementujące FromResidual).

Błędy niestandardowe

Możemy zdefiniować własne typy błędów, implementując cechę std::fmt::Display (i opcjonalnie std::error::Error), aby zapewnić czytelną dla człowieka reprezentację błędu:

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 {}

Spróbuj sam

Ćwiczenie 1: Odczyt pliku z ? operator

Ćwiczenie 2: Analiza i przetwarzanie liczby

Ćwiczenie 3: Zdefiniuj błąd niestandardowy