Lær at programmere i Rust · Lektion

Result og ?-operatoren

Videregiv fejl

Lektion 1 af 413 trin

Result og ?-operatoren er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær at programmere i Rust, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.

Result-typen

Result<T, E> repræsenterer en operation, der enten lykkes med Ok(T) eller mislykkes med Err(E). Det er Rusts primære type til fejlhåndtering.

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

Match på Result

Du kan håndtere begge udfald eksplicit med match.

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

Returnering af Result

Funktioner, der kan mislykkes, returnerer en Result, så den kaldende kode kan afgøre, hvordan fejl skal håndteres.

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

? -operatoren

Operatoren ? pakker en Ok-værdi ud eller returnerer tidligt Err fra funktionen. Den erstatter udførlig match-og-returnér-kode.

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

Kædning med ?

Flere fejlslagne trin er nemme at læse, når de kædes sammen med ?; den første fejl afbryder resten.

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

? i main

main kan returnere Result, så ? fungerer også dér. Et returneret Err afslutter programmet med en exitkode, der ikke er nul.

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

Nyttige Result-metoder

Praktiske kombinatorer:

unwrap_or(default) — værdi eller en reserveværdi
map — transformér Ok-værdien
map_err — transformér fejlen
is_ok / is_err — kontrollér varianten

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

Fra Option til Result

Konvertér en Option til en Result med ok_or, så ? kan videreføre en meningsfuld fejl.

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(""));
}

Sådan konverterer ? fejl

Når fejltyperne er forskellige, kalder ? From::from for at konvertere fejlen til funktionens erklærede fejltype. Det muliggør praktisk fejlhåndtering på tværs af lag.

Undgå unwrap i produktionskode

unwrap og expect går i panik ved Err. De er fine i eksempler og tests, men foretræk ? eller eksplicit håndtering i rigtig kode, så fejl kan håndteres.

Kædning med and_then

and_then kører kun det næste fejlslagne trin, hvis det forrige lykkedes, og fører værdien videre.

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

Hurtigt tjek

Hvad gør operatoren ?, når den anvendes på en Result, der er Err?

Besvar den i den interaktive lektion

Opsummering

Du har lært fejlhåndtering baseret på Result:

Result<T, E> modellerer succes eller fejl
? pakker Ok ud eller returnerer Err tidligt
? fungerer i funktioner og main, der returnerer Result
Kombinatorer som map, map_err, unwrap_or og ok_or er nyttige
Undgå unwrap i produktionskode

Gratis at komme i gang

Lær Rust med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 39
Lektioner: 144

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Result og ?-operatoren” gratis?

Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Result og ?-operatoren”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Result og ?-operatoren”?

Videregiv fejl Du øver dig i Lær at programmere i Rust med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Lær at programmere i Rust?

Der kræves ingen tidligere erfaring. Lær at programmere i Rust på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Result og ?-operatoren”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Lær at programmere i Rust-lektion?

Ja. Alle Lær at programmere i Rust-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

Result og ?-operatoren
thiserror
anyhow
Fejlkovertering

← Tilbage til Lær at programmere i Rust