Rust-ohjelmoinnin perusteet · Oppitunti

Virheiden muuntaminen

From-toteutukset.

Oppitunti 4/413 vaihetta

Virheiden muuntaminen on ilmainen Rust-ohjelmoinnin perusteet-oppitunti CoddyKitissä. Tämä on oppitunti 4/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Rust-ohjelmoinnin perusteet-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Rust-ohjelmoinnin perusteet-kurssilla on yhteensä 4 oppituntia.

Miksi virheitä muunnetaan?

Koodin eri kerrokset tuottavat erilaisia virhetyyppejä. Jotta virheet voidaan välittää yhden funktion läpi, alemman tason virheet on muunnettava yhtenäiseksi tyypiksi. Rust tekee tämän From-traitin avulla.

From-trait

From<T> määrittää, miten yksi tyyppi muodostetaan toisesta. Kun toteutatte sen omalle virhetyypillenne, voitte muuntaa lähdevirheet kyseiseksi tyypiksi.

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

Miten ? käyttää From-traitia

Kun kirjoitatte expr? ja virhetyyppi poikkeaa funktion palauttamasta virhetyypistä, operaattori kutsuu From::from-funktiota muunnosta varten. Tämä mahdollistaa saumattoman virheiden välityksen.

Yhtenäinen virhetyyppi

Määritelkää enum, joka voi sisältää kaikki virhetyypit, joita funktionne saattaa tuottaa.

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

From-traitin toteuttaminen

Kirjoittakaa jokaiselle lähdevirheelle From-impl-toteutus, jotta se muunnetaan vastaavaksi variantiksi.

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

Automaattinen välitys

Kun nämä impl-toteutukset ovat paikoillaan, ? muuntaa jokaisen virheen automaattisesti AppError-tyypiksi.

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 on peilikuva

From<A> for B-toteutus antaa automaattisesti käyttöön myös A: Into<B>-toteutuksen. Suosikaa From-traitin toteuttamista, sillä saatte into()-metodin samalla ilmaiseksi.

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

Trait-objektien paketoiminen

Nopeisiin muunnoksiin Box<dyn Error> hyväksyy minkä tahansa virhetyypin, koska standardikirjasto tarjoaa siihen yleiset From-impl-toteutukset.

use std::error::Error;

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

From-toteutuksia luovat cratet

Jokaisen From-impl-toteutuksen kirjoittaminen käsin on työlästä. thiserror-craten #[from]-attribuutti luo ne automaattisesti, ja anyhow muuntaa kaiken automaattisesti yhdeksi tyypiksi.

Lähestymistavan valitseminen

Yhteenveto muunnosstrategioista:

Manuaaliset From-impl-toteutukset — täysi hallinta, enemmän koodia
thiserror #[from] — tyypitetyt virheet, automaattisesti luodut impl-toteutukset
Box<dyn Error> tai anyhow — mahdollisimman vähän toisteista koodia

Kontekstin lisääminen muunnoksen aikana

From-impl-toteutus voi tehdä muutakin kuin kääriä virheen: se voi rikastaa sitä. Tässä muunnos lisää virheeseen ylimääräistä kontekstia, joten lopullinen virhe on informatiivisempi.

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

Pikatarkistus

Mitä traitia ?-operaattori käyttää yhden virhetyypin muuntamiseen toiseksi?

Vastaa interaktiivisessa oppitunnissa

Kertaus

Opitte virheiden muuntamisen:

? muuntaa virheet From-traitin avulla
Toteuttakaa From<Source> omalle virheenumillenne
From antaa automaattisesti käyttöön Into-traitin ja into()-metodin
Box<dyn Error> hyväksyy minkä tahansa virheen
thiserror ja anyhow automatisoivat toisteisen koodin

Aloita maksutta

Opi Rust tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 39
Oppitunnit: 144

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Virheiden muuntaminen” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Rust-ohjelmoinnin perusteet-oppimispolun 3 oppituntia, myös oppitunnin “Virheiden muuntaminen”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Rust-ohjelmoinnin perusteet-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Virheiden muuntaminen”?

From-toteutukset. Harjoittelet Rust-ohjelmoinnin perusteet-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Rust-ohjelmoinnin perusteet-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Rust-ohjelmoinnin perusteet-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 4/4.

Kuinka kauan ”Virheiden muuntaminen”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Rust-ohjelmoinnin perusteet-oppitunnilla?

Kyllä. Jokainen Rust-ohjelmoinnin perusteet-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Rust-ohjelmoinnin perusteet