Learn Rust Coding · Lektion

Fehlerkonvertierung

From-Implementierungen

Fehlerkonvertierung ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Warum Fehler umwandeln?

Verschiedene Schichten eines Programms erzeugen unterschiedliche Fehlertypen. Um sie durch eine Funktion weiterzureichen, müssen Sie Fehler aus tieferen Schichten in einen einheitlichen Typ umwandeln. Rust erledigt dies über das Trait From.

Das From-Trait

From<T> definiert, wie ein Typ aus einem anderen erstellt wird. Wenn Sie es für Ihren Fehlertyp implementieren, können Sie Quellfehler in diesen Typ umwandeln.

trait From<T> {
    fn from(value: T) -> Self;
}

Wie ? From verwendet

Wenn Sie expr? schreiben und sich der Fehlertyp vom Rückgabefehler der Funktion unterscheidet, ruft der Operator From::from auf, um ihn umzuwandeln. Darauf beruht die nahtlose Weitergabe.

Ein einheitlicher Fehlertyp

Definieren Sie eine Enum, die jede Fehlerart aufnehmen kann, die Ihre Funktion ausgeben kann.

#[derive(Debug)]
enum AppError {
    Io(std::io::Error),
    Parse(std::num::ParseIntError),
}

From implementieren

Schreiben Sie für jeden Quellfehler eine From-Implementierung, damit er in die passende Variante umgewandelt wird.

impl From<std::io::Error> for AppError {
    fn from(e: std::io::Error) -> Self {
        AppError::Io(e)
    }
}

impl From<std::num::ParseIntError> for AppError {
    fn from(e: std::num::ParseIntError) -> Self {
        AppError::Parse(e)
    }
}

Automatisch weitergeben

Mit diesen Implementierungen wandelt ? jeden Fehler automatisch in AppError um.

fn read_count(path: &str) -> Result<i32, AppError> {
    let text = std::fs::read_to_string(path)?; // io::Error -> AppError
    let n: i32 = text.trim().parse()?;          // ParseIntError -> AppError
    Ok(n)
}

Into ist das Gegenstück

Die Implementierung von From<A> for B stellt automatisch A: Into<B> bereit. Implementieren Sie vorzugsweise From; dadurch erhalten Sie into() kostenlos.

fn make() -> AppError {
    let e: std::io::Error = std::io::Error::other("boom");
    e.into() // uses From<io::Error> for AppError
}

Trait-Objekte in Boxen verpacken

Für schnelle Umwandlungen akzeptiert Box<dyn Error> jeden Fehlertyp, da die Standardbibliothek allgemeine From-Implementierungen dorthin bereitstellt.

use std::error::Error;

fn run() -> Result<(), Box<dyn Error>> {
    let n: i32 = "42".parse()?; // ParseIntError -> Box<dyn Error>
    println!("{n}");
    Ok(())
}

Crates, die From generieren

Jede From-Implementierung von Hand zu schreiben, ist mühsam. Das Attribut #[from] von thiserror generiert sie, und anyhow wandelt automatisch alles in einen einzigen Typ um.

Einen Ansatz auswählen

Zusammenfassung der Umwandlungsstrategien:

Manuelle From-Implementierungen — vollständige Kontrolle, mehr Code
thiserror #[from] — typisierte Fehler, generierte Implementierungen
Box<dyn Error> oder anyhow — minimaler Aufwand

Beim Umwandeln Kontext hinzufügen

Eine From-Implementierung kann mehr tun, als einen Fehler zu umschließen — sie kann ihn anreichern. Hier fügt die Umwandlung zusätzlichen Kontext hinzu, sodass der endgültige Fehler aussagekräftiger ist.

impl From<std::num::ParseIntError> for AppError {
    fn from(e: std::num::ParseIntError) -> Self {
        // could log or annotate here before wrapping
        AppError::Parse(e)
    }
}

Schnelltest

Welches Trait verwendet der Operator ?, um einen Fehlertyp in einen anderen umzuwandeln?

Zusammenfassung

Sie haben die Fehlerumwandlung gelernt:

? wandelt Fehler über das Trait From um
Implementieren Sie From<Source> für Ihre Fehler-Enum
From stellt kostenlos Into und into() bereit
Box<dyn Error> akzeptiert jeden Fehler
thiserror und anyhow automatisieren den Boilerplate-Code

Häufig gestellte Fragen

Ist die Lektion „Fehlerkonvertierung“ kostenlos?

Ja — der vollständige Text von „Fehlerkonvertierung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Fehlerkonvertierung“?

From-Implementierungen Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Fehlerkonvertierung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding