Learn Rust Coding · Lezione

Conversione degli errori

Implementazioni di From

Conversione degli errori è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.

Perché convertire gli errori?

Livelli diversi del codice producono tipi di errore diversi. Per propagarli attraverso un'unica funzione, è necessario convertire gli errori di livello inferiore in un tipo unificato. Rust esegue questa operazione tramite il trait From.

Il trait From

From<T> definisce come costruire un tipo a partire da un altro. Implementarlo per il proprio tipo di errore consente di convertire in esso gli errori origine.

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

Come ? usa From

Quando scrive expr? e il tipo di errore è diverso da quello restituito dalla funzione, l'operatore chiama From::from per convertirlo. Questo è il meccanismo alla base della propagazione senza interruzioni.

Un tipo di errore unificato

Definisca un enum che possa contenere ogni tipo di errore che la funzione può emettere.

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

Implementare From

Scriva un'implementazione di From per ogni errore origine, in modo che venga convertito nella variante corrispondente.

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

Propagare automaticamente

Con queste implementazioni, ? converte gratuitamente ogni errore in AppError.

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 è lo specchio

Implementare From<A> for B fornisce automaticamente A: Into<B>. Preferisca implementare From: otterrà into() gratuitamente.

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

Racchiudere i trait object

Per conversioni rapide, Box<dyn Error> accetta qualsiasi tipo di errore, poiché la libreria standard fornisce implementazioni generiche di From verso di esso.

use std::error::Error;

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

I crate che generano From

Scrivere a mano ogni implementazione di From è noioso. L'attributo #[from] di thiserror le genera automaticamente, mentre anyhow converte tutto in un unico tipo.

Scegliere un approccio

Riepilogo delle strategie di conversione:

Implementazioni manuali di From — controllo completo, più codice
thiserror #[from] — errori tipizzati, implementazioni generate
Box<dyn Error> o anyhow — configurazione minima

Aggiungere contesto durante la conversione

Un'implementazione di From può fare più che racchiudere un errore: può arricchirlo. In questo caso la conversione aggiunge ulteriore contesto, rendendo l'errore finale più informativo.

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

Verifica rapida

Quale trait usa l'operatore ? per convertire un tipo di errore in un altro?

Riepilogo

Ha imparato a convertire gli errori:

? converte gli errori tramite il trait From
Implementi From<Source> per il proprio enum di errore
From fornisce gratuitamente Into e into()
Box<dyn Error> accetta qualsiasi errore
thiserror e anyhow automatizzano il codice ripetitivo

Domande Frequenti

La lezione «Conversione degli errori» è gratuita?

Sì — il testo completo di «Conversione degli errori» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.

Cosa imparerò in «Conversione degli errori»?

Implementazioni di From Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn Rust Coding?

Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Conversione degli errori»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Result e operatore ?
thiserror
anyhow
Conversione degli errori

← Torna a Learn Rust Coding