Learn Rust Coding · Lektion

Result und der ?-Operator

Fehler weitergeben

Result und der ?-Operator ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Der Result-Typ

Result<T, E> stellt eine Operation dar, die mit Ok(T) erfolgreich sein oder mit Err(E) fehlschlagen kann. Er ist Rusts wichtigster Typ für die Fehlerbehandlung.

fn main() {
    let parsed: Result<i32, _> = "42".parse::<i32>();
    println!("{:?}", parsed);
}

Result abgleichen

Sie können beide Ergebnisse mit match explizit behandeln.

fn main() {
    match "oops".parse::<i32>() {
        Ok(n) => println!("got {n}"),
        Err(e) => println!("error: {e}"),
    }
}

Result zurückgeben

Funktionen, die fehlschlagen können, geben ein Result zurück, sodass der Aufrufer entscheiden kann, wie Fehler behandelt werden.

fn halve(n: i32) -> Result<i32, String> {
    if n % 2 == 0 {
        Ok(n / 2)
    } else {
        Err("odd number".to_string())
    }
}

fn main() {
    println!("{:?}", halve(10));
    println!("{:?}", halve(7));
}

Der ?-Operator

Der Operator ? entpackt einen Ok-Wert oder gibt Err frühzeitig aus der Funktion zurück. Er ersetzt ausführlichen Match-and-Return-Code.

fn double_str(s: &str) -> Result<i32, std::num::ParseIntError> {
    let n = s.parse::<i32>()?;
    Ok(n * 2)
}

fn main() {
    println!("{:?}", double_str("21"));
    println!("{:?}", double_str("x"));
}

Mit ? verketten

Mehrere fehlerschlagende Schritte lassen sich mit ? übersichtlich verketten; der erste Fehler bricht die weiteren Schritte ab.

fn sum_two(a: &str, b: &str) -> Result<i32, std::num::ParseIntError> {
    let x = a.parse::<i32>()?;
    let y = b.parse::<i32>()?;
    Ok(x + y)
}

fn main() {
    println!("{:?}", sum_two("3", "4"));
}

? in main

main kann Result zurückgeben, daher funktioniert ? auch dort. Ein zurückgegebenes Err beendet das Programm mit einem Exit-Code ungleich null.

fn main() -> Result<(), std::num::ParseIntError> {
    let n: i32 = "100".parse()?;
    println!("parsed {n}");
    Ok(())
}

Nützliche Result-Methoden

Praktische Combinators:

unwrap_or(default) – Wert oder Ersatzwert
map – den Ok-Wert umwandeln
map_err – den Fehler umwandeln
is_ok / is_err – die Variante prüfen

fn main() {
    let n = "x".parse::<i32>().unwrap_or(-1);
    println!("{n}");
}

Option in Result umwandeln

Wandeln Sie ein Option mit ok_or in ein Result um, damit ? einen aussagekräftigen Fehler weitergeben kann.

fn first_char(s: &str) -> Result<char, String> {
    let c = s.chars().next().ok_or("empty string".to_string())?;
    Ok(c)
}

fn main() {
    println!("{:?}", first_char("hi"));
    println!("{:?}", first_char(""));
}

Wie ? Fehler umwandelt

Wenn sich die Fehlertypen unterscheiden, ruft ? From::from auf, um den Fehler in den deklarierten Fehlertyp der Funktion umzuwandeln. Dadurch wird eine komfortable Fehlerbehandlung über mehrere Ebenen hinweg ermöglicht.

unwrap in Produktionscode vermeiden

unwrap und expect lösen bei Err einen Panic aus. Für Beispiele und Tests sind sie in Ordnung; in echtem Code sollten Sie jedoch ? oder eine explizite Behandlung bevorzugen, damit Fehler beherrschbar bleiben.

Mit and_then verketten

and_then führt den nächsten fehlerschlagenden Schritt nur aus, wenn der vorherige erfolgreich war, und reicht den Wert dabei weiter.

fn main() {
    let result = "8"
        .parse::<i32>()
        .and_then(|n| Ok(n * 2));
    println!("{:?}", result);
}

Schnelltest

Was bewirkt der Operator ?, wenn er auf ein Result angewendet wird, das Err ist?

Zusammenfassung

Sie haben die fehlerbasierte Behandlung mit Result gelernt:

Result<T, E> bildet Erfolg oder Fehlschlag ab
? entpackt Ok oder gibt bei einem Fehler frühzeitig Err zurück
? funktioniert in Funktionen und in main, die Result zurückgeben
Kombinatoren wie map, map_err, unwrap_or und ok_or sind hilfreich
Vermeiden Sie unwrap in Produktionscode

Häufig gestellte Fragen

Ist die Lektion „Result und der ?-Operator“ kostenlos?

Ja — der vollständige Text von „Result und der ?-Operator“ 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 „Result und der ?-Operator“?

Fehler weitergeben 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 1 von 4.

Wie lange dauert die Lektion „Result und der ?-Operator“?

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

Result und der ?-Operator
thiserror
anyhow
Fehlerkonvertierung

← Zurück zu Learn Rust Coding