Lær Rust-programmering · leksjon

Feilkonvertering

From-implementasjoner

Leksjon 4 av 413 trinn

Feilkonvertering er en gratis leksjon i Lær Rust-programmering på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Lær Rust-programmering, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Lær Rust-programmering inneholder totalt 4 leksjoner.

Hvorfor konvertere feil?

Ulike kodelag produserer ulike feiltyper. For å sende dem gjennom én funksjon må De konvertere feil på lavere nivå til en samlet type. Rust gjør dette gjennom From-traitet.

From-traitet

From<T> definerer hvordan én type bygges fra en annen. Når De implementerer det for feiltypen Deres, kan De konvertere kildefeil til den.

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

Hvordan ? bruker From

Når De skriver expr? og feiltypen er forskjellig fra funksjonens returtype for feil, kaller operatoren From::from for å konvertere den. Dette er magien bak sømløs videreføring.

En samlet feiltype

Definer en enum som kan inneholde hver type feil funksjonen kan produsere.

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

Implementere From

Skriv en From-impl for hver kildefeil, slik at den konverteres til den tilsvarende varianten.

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

Sende videre automatisk

Når disse impl-ene er på plass, konverterer ? hver feil til AppError automatisk.

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 er speilbildet

Implementering av From<A> for B gir Dem automatisk A: Into<B>. Foretrekk å implementere From; da får De into() med på kjøpet.

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

Bokse trait-objekter

For raske konverteringer godtar Box<dyn Error> alle feiltyper, siden standardbiblioteket tilbyr generelle From-impl-er til denne typen.

use std::error::Error;

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

Crater som genererer From

Det er kjedelig å skrive hver From-impl for hånd. Attributtet #[from] i thiserror genererer dem, mens anyhow automatisk konverterer alt til én type.

Velge en fremgangsmåte

Oppsummering av konverteringsstrategier:

Manuelle From-impl-er — full kontroll, mer kode
thiserror #[from] — typede feil, genererte impl-er
Box<dyn Error> eller anyhow — minimalt med standardkode

Legge til kontekst under konvertering

En From-impl kan gjøre mer enn å pakke inn feilen — den kan berike den. Her legger konverteringen til ekstra kontekst, slik at den endelige feilen blir mer informativ.

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

Hurtigsjekk

Hvilket trait bruker operatoren ? til å konvertere én feiltype til en annen?

Besvar den i den interaktive leksjonen

Oppsummering

De har lært om feilkonvertering:

? konverterer feil via From-traitet
Implementer From<Source> for feil-enum-en Deres
From gir Dem Into og into() automatisk
Box<dyn Error> godtar alle feil
thiserror og anyhow automatiserer standardkoden

Gratis å komme i gang

Lær deg Rust med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 39
Leksjoner: 144

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Feilkonvertering» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Lær Rust-programmering, inkludert «Feilkonvertering», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Lær Rust-programmering inneholder totalt 4 leksjoner.

Hva lærer jeg i «Feilkonvertering»?

From-implementasjoner Du øver på Lær Rust-programmering med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Lær Rust-programmering?

Ingen tidligere erfaring er nødvendig. Lær Rust-programmering på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Feilkonvertering»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Lær Rust-programmering-leksjonen?

Ja. Alle Lær Rust-programmering-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Lær Rust-programmering