Learn Rust Coding · Lezione

Result e operatore ?

Propagazione degli errori

Result e operatore ? è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 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.

Il tipo Result

Result<T, E> rappresenta un'operazione che può riuscire con Ok(T) oppure fallire con Err(E). È il principale tipo di Rust per la gestione degli errori.

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

Corrispondenza su Result

Può gestire esplicitamente entrambi i risultati con match.

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

Restituire Result

Le funzioni che possono fallire restituiscono un Result, lasciando al chiamante la scelta di come gestire gli errori.

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

L'operatore ?

L'operatore ? estrae un valore Ok oppure restituisce anticipatamente Err dalla funzione. Sostituisce il codice prolisso che esegue una corrispondenza e poi restituisce il risultato.

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

Concatenare con ?

Più passaggi soggetti a errore risultano chiari quando vengono concatenati con ?; il primo errore interrompe immediatamente i passaggi successivi.

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

? in main

main può restituire Result, quindi anche lì funziona ?. Un Err restituito termina il programma con un codice di uscita diverso da zero.

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

Metodi utili di Result

Combinatori utili:

unwrap_or(default) — il valore oppure un'alternativa
map — trasforma il valore Ok
map_err — trasforma l'errore
is_ok / is_err — verifica la variante

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

Da Option a Result

Converta un Option in un Result con ok_or, così ? può propagare un errore significativo.

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

Come ? converte gli errori

Quando i tipi di errore sono diversi, ? chiama From::from per convertire l'errore nel tipo dichiarato dalla funzione. Questo permette una gestione degli errori agevole tra i vari livelli.

Eviti unwrap in produzione

unwrap e expect causano un panic su Err. Sono adatti per esempi e test, ma nel codice reale preferisca ? o una gestione esplicita, così gli errori restano recuperabili.

Concatenare con and_then

and_then esegue il passaggio successivo soggetto a errore solo se quello precedente è riuscito, passando il valore da un passaggio all'altro.

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

Verifica rapida

Che cosa fa l'operatore ? quando viene applicato a un Result che contiene Err?

Riepilogo

Ha imparato a gestire gli errori basandosi su Result:

Result<T, E> rappresenta un successo o un fallimento
? estrae Ok oppure restituisce anticipatamente Err
? funziona nelle funzioni e in main che restituiscono Result
Combinatori come map, map_err, unwrap_or e ok_or sono utili
Eviti unwrap in produzione

Domande Frequenti

La lezione «Result e operatore ?» è gratuita?

Sì — il testo completo di «Result e operatore ?» è 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 «Result e operatore ?»?

Propagazione degli errori 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 1 di 4.

Quanto tempo richiede la lezione «Result e operatore ?»?

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

← Torna a Learn Rust Coding