Gestione degli errori in ruggine

La gestione degli errori è praticamente la seconda cosa più comune per un programmatore, tranne che fare errori, ovviamente. Come sviluppatore, incontrerai scenari in cui devi aspettarti un errore e creare un'azione se accade.

Sebbene il compilatore implementerà la gestione degli errori predefiniti, è bene capire come gestire gli errori per la logica personalizzata. La gestione degli errori impedirà al programma di restituire l'output indesiderato o terminare in modo anomalo.

Esploriamo come gestire gli errori nel linguaggio di programmazione ruggine.

Tipi di errore di ruggine

Esistono due tipi di errori in ruggine:

1. Errori recuperabili
2. Errori irregolari

Errori irregolari

Gli errori irrecuperabili si riferiscono ai tipi di errori che causano morire o uscire in modo anomalo di un programma. Un esempio sarebbe accedere a un indice fuori confine in un array.

Rust usa il panico! Macro per gestire errori irregovibili. Supponiamo che il compilatore incontri il panico! Macro nel tuo codice. Stampa i messaggi specificati, pulisce lo stack e termina il programma.

Il panico! La macro è molto utile quando si verificano errori da cui il programma non può recuperare.

Prendi un semplice programma fornito di seguito che illustra come utilizzare la macro Panic:

fn main ()
panico!("Sono morto!!");

Una volta eseguito il codice precedente, è necessario ottenere un output come mostrato di seguito:

Chiamare il panico! fa uscire e stampare il programma il metodo di panico specificato.

Backtracing un panico

Rust ci consente di contrastare la fonte di errore utilizzando la variabile di ambiente Rust_Backtrace. Il backtracing si riferisce a un elenco di funzioni che sono state chiamate prima dell'errore.

Prendi l'esempio fornito di seguito:

fn main ()
let vec = vec![1,2,3,4,5];
println!("", Vec [5]);

Nell'esempio precedente, stiamo tentando di leggere un indice di array out-of-bounds. Ciò dovrebbe causare il panico e l'uscita del programma.

Di seguito è riportato un output di esempio di output:

Come puoi vedere dall'output, il compilatore ci dice.

Possiamo farlo usando il seguente comando:

$ Rust_backtrace = 1 carico

Questo dovrebbe restituire l'output di backtrace come:

Questo dovrebbe restituire un output dettagliato di come l'errore è avvenuto nel tuo codice. Per un'opzione interamente verbosa, è possibile utilizzare Rust_BackTrace = Full.

Errori recuperabili

In genere, raramente dovrai gestire errori irresistibili. Per gestire errori recuperabili in ruggine, utilizziamo il risultato enum, che contiene due varianti: OK e ERR.

Prendiamo il seguente programma semplice nel tentativo di aprire un file:

usestd :: fs :: file;
fnMain ()
let file = file :: open ("ciao.TXT");
println!(":?", file);

Il codice precedente tenta di aprire un file inesistente. L'esecuzione del programma fornito sopra dovrebbe restituire come:

Err (OS Code: 2, Kind: Notfound, Messaggio: "Il sistema non può trovare il file specificato.")

Tuttavia, possiamo definire l'azione che vogliamo se il file non esiste. Un esempio è mostrato di seguito:

usestd :: fs :: file;
fnMain ()
let file = file :: open ("ciao.TXT");
Match File
Ok (file) =>
println!("File trovato: :?", file)
,
Err (_error) =>
println!("file non trovato")

Qui, utilizziamo l'operatore Match per verificare se il file ha restituito un errore o OK. Quindi, prendiamo le azioni per ogni caso.

Possiamo anche utilizzare il metodo aspettativo per creare specifiche di gestione degli errori personalizzati.

Per esempio:

usestd :: fs :: file;
fnMain ()
let file = file :: open ("ciao.TXT")
.Aspettatevi ("Errore si è verificato durante la lettura del file");

Il metodo aspettativo, che chiamerà la macro panico in un errore, si riscontra quando si apre il file.

Chiusura

Questo tutorial ha riguardato i fondamenti della gestione degli errori nel linguaggio di programmazione ruggine. Inoltre, questa guida ha discusso dei due tipi di errori: errori recuperabili ed errori irrecuperabili. Speriamo che tu abbia trovato questo articolo utile. Controlla gli altri articoli di suggerimento Linux per ulteriori suggerimenti e informazioni.