Nessun prodotto nel carrello.
SE VUOI PRENDERE LA CERTIFICAZIONE PER QUESTO CORSO CLICCA QUI
Corso su Gestione degli Errori e Stampa su Standard Error
Scrivere Messaggi di Errore su Standard Error invece di Standard Output
Attualmente, stiamo scrivendo tutti i nostri output sul terminale usando il macro println!. Nella maggior parte dei terminali, ci sono due tipi di output: standard output (stdout) per informazioni generali e standard error (stderr) per i messaggi di errore. Questa distinzione consente agli utenti di scegliere di indirizzare l’output di successo di un programma su un file ma di stampare comunque i messaggi di errore sullo schermo.
Il macro println! è in grado solo di stampare su standard output, quindi dobbiamo usare qualcos’altro per stampare su standard error.
Verifica di Dove Vengono Scritti gli Errori
Prima, osserviamo come il contenuto stampato da minigrep viene attualmente scritto su standard output, inclusi eventuali messaggi di errore che vogliamo scrivere su standard error invece. Lo faremo reindirizzando il flusso di output standard su un file causando intenzionalmente un errore. Non reindirizzeremo il flusso di errori standard, quindi qualsiasi contenuto inviato a standard error continuerà a essere visualizzato sullo schermo.
I programmi da riga di comando devono inviare i messaggi di errore al flusso di errori standard in modo che possiamo comunque vedere i messaggi di errore sullo schermo anche se reindirizziamo il flusso di output standard su un file. Il nostro programma attualmente non si comporta bene: stiamo per vedere che salva l’output del messaggio di errore su un file invece!
Per dimostrare questo comportamento, eseguiremo il programma con > e il percorso del file, output.txt, a cui vogliamo reindirizzare il flusso di output standard. Non passeremo alcun argomento, il che dovrebbe causare un errore:
bash
$ cargo run > output.txt
La sintassi > dice alla shell di scrivere il contenuto dello standard output su output.txt invece dello schermo. Non abbiamo visto il messaggio di errore che ci aspettavamo stampato sullo schermo, quindi significa che deve essere finito nel file. Ecco cosa contiene output.txt:
plaintext
Problem parsing arguments: not enough arguments
Sì, il nostro messaggio di errore viene stampato su standard output. È molto più utile che i messaggi di errore come questo vengano stampati su standard error in modo che solo i dati di un’esecuzione riuscita finiscano nel file. Cambieremo questo.
Stampa degli Errori su Standard Error
Utilizzeremo il codice nel Listing 12-24 per cambiare il modo in cui vengono stampati i messaggi di errore. A causa del refactoring che abbiamo fatto in precedenza in questo capitolo, tutto il codice che stampa i messaggi di errore è in una sola funzione, main. La libreria standard fornisce il macro eprintln! che stampa sul flusso di errore standard, quindi cambieremo i due luoghi in cui stavamo chiamando println! per stampare gli errori usando eprintln! invece.
rust
fn main() {
let args: Vec<String> = env::args().collect(); let config = Config::build(&args).unwrap_or_else(|err| {
eprintln!("Problem parsing arguments: {err}");
process::exit(1);
});
if let Err(e) = minigrep::run(config) {
eprintln!("Application error: {e}");
process::exit(1);
}
}
Esecuzione del Programma e Visualizzazione degli Errori
Eseguiamo ora nuovamente il programma allo stesso modo, senza argomenti e reindirizzando lo standard output con >:
bash
$ cargo run > output.txt
Ora vediamo l’errore sullo schermo e output.txt non contiene nulla, che è il comportamento che ci aspettiamo dei programmi da riga di comando.
Eseguiamo ora nuovamente il programma con argomenti che non causano un errore ma reindirizzano comunque lo standard output su un file, come segue:
bash
$ cargo run -- to poem.txt > output.txt
Non vedremo alcun output sul terminale, e output.txt conterrà i nostri risultati.
Questo dimostra che ora stiamo usando standard output per l’output di successo e standard error per l’output di errore come appropriato.
Riassunto
Questo capitolo ha ricapitolato alcuni dei concetti principali che hai imparato finora e ha coperto come eseguire operazioni di I/O comuni in Rust. Utilizzando gli argomenti da riga di comando, i file, le variabili d’ambiente e il macro eprintln! per stampare gli errori, sei ora pronto per scrivere applicazioni da riga di comando. Combinato con i concetti dei capitoli precedenti, il tuo codice sarà ben organizzato, archivierà i dati in modo efficace nelle strutture dati appropriate, gestirà gli errori in modo gradevole e sarà ben testato.
Successivamente, esploreremo alcune funzionalità di Rust che sono state influenzate dai linguaggi funzionali: chiusure e iteratori.
