Lär dig programmera i Rust · Lektion

Felkonvertering

From-implementationer

Lektion 4 av 413 steg

Felkonvertering är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 4 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.

Varför konvertera fel?

Olika kodlager producerar olika feltyper. För att skicka dem vidare genom en och samma funktion behöver ni konvertera fel på lägre nivå till en enhetlig typ. Rust gör detta via traiten From.

Trait-en From

From<T> definierar hur en typ skapas från en annan. Om ni implementerar den för er feltyp kan ni konvertera källfel till den.

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

Hur ? använder From

När ni skriver expr? och feltypen skiljer sig från funktionens returfel anropar operatorn From::from för att konvertera den. Detta är det som möjliggör sömlös vidarebefordran.

En enhetlig feltyp

Definiera en enum som kan innehålla varje typ av fel som funktionen kan generera.

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

Implementera From

Skriv en From-implementation för varje källfel så att det konverteras till motsvarande variant.

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

Automatisk vidarebefordran

När dessa implementationer finns på plats konverterar ? varje fel till AppError automatiskt.

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 är spegelbilden

Om ni implementerar From<A> for B får ni automatiskt A: Into<B>. Implementera helst From; då får ni into() på köpet.

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

Boxa trait-objekt

För snabba konverteringar accepterar Box<dyn Error> alla feltyper, eftersom standardbiblioteket tillhandahåller generella From-implementationer till den.

use std::error::Error;

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

Crate-paket som genererar From

Det är omständligt att skriva varje From-implementation för hand. Attributet #[from] i thiserror genererar dem, och anyhow konverterar automatiskt allt till en enda typ.

Välja metod

Sammanfattning av konverteringsstrategier:

Manuella From-implementationer — full kontroll, mer kod
thiserror #[from] — typade fel och genererade implementationer
Box<dyn Error> eller anyhow — minimalt ceremoniel

Lägga till sammanhang under konvertering

En From-implementation kan göra mer än att bara omsluta ett fel — den kan berika det. Här lägger konverteringen till extra sammanhang så att det slutliga felet blir mer informativt.

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

Snabb kontroll

Vilken trait använder operatorn ? för att konvertera en feltyp till en annan?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er felkonvertering:

? konverterar fel via traiten From
Implementera From<Source> för er fel-enum
From ger er Into och into() på köpet
Box<dyn Error> accepterar alla fel
thiserror och anyhow automatiserar den upprepande koden

Gratis att börja

Lär dig Rust med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 39
Lektioner: 144

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Felkonvertering” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Felkonvertering”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.

Vad lär jag mig i ”Felkonvertering”?

From-implementationer Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?

Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Felkonvertering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?

Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lär dig programmera i Rust