Gestione delle eccezioni in Ruby

La gestione delle eccezioni si riferisce al processo di previsione e definizione dei modi per gestire gli errori raccolti in un programma durante l'esecuzione. Un errore, nella maggior parte dei casi, si riferisce a un evento o occorrenza imprevisti durante l'esecuzione del programma. Ad esempio, può verificarsi un errore durante la lettura di un file a causa del file non esistente o dell'utente che non ha l'autorizzazione giusta per leggere o scrivere nel file.

Questo tutorial ti mostrerà come implementare la gestione delle eccezioni in Ruby usando i blocchi di raccolta e salvataggio.

Uso di base

La maggior parte dei linguaggi di programmazione implementa la gestione delle eccezioni utilizzando il blocco Try and Catch. Tuttavia, come tutto il resto in Ruby, le parole chiave sono più descrittive.

Possiamo esprimere la sintassi generale come mostrato di seguito:

inizio
rasaxception
# Aumenta l'ecxeption
Eccezione di salvataggio
# Blocco di salvataggio
FINE

Alleggiamo il blocco di gestione delle eccezioni in una dichiarazione di inizio e fine. All'interno di queste affermazioni, definiamo i blocchi di raccolta e salvataggio.

Nel rilancio, definiamo l'eccezione, che possiamo sollevare manualmente o far sì che l'interprete di Ruby lo generi. Per impostazione predefinita, il parametro per il blocco di aumento è runtimeerror

Il prossimo è il blocco di salvataggio. Come suggerisce il nome, questo blocco arriva in soccorso quando si verifica un'eccezione. Ci vuole il controllo dell'esecuzione del programma.

Ruby confronterà l'eccezione sollevata dal blocco di aumento rispetto ai parametri passati al blocco di salvataggio. Se l'eccezione è dello stesso tipo o di una superclasse, innesca il blocco di salvataggio.

Esempio di gestione delle eccezioni in Ruby

Possiamo implementare un semplice esempio per illustrare come funziona la gestione delle eccezioni in Ruby:

def err_me
inizio
mette "Ciao lì!"
sollevare "tipo di stringa"
salvare
mette "non importa, sono fisso!"
FINE
FINE
err_me

Nell'esempio sopra, definiamo una funzione con un blocco di eccezione.

Solleviamo manualmente un'eccezione, che interrompe il flusso di esecuzione del programma ed entra nel blocco di salvataggio. Ciò esegue le azioni nel blocco in questo caso, una dichiarazione e uscite.

Se si aggiunge un blocco di codice immediatamente dopo l'aumento e prima del blocco di salvataggio, non esegui perché il blocco di salvataggio gestisce immediatamente il flusso del programma.

Per impostazione predefinita, il blocco di salvataggio utilizza il parametro standardrror. Tuttavia, ci sono altri tipi di errori in Ruby, incluso.

1. Errore di sintassi
2. Ioerror
3. Regexperror
4. Threaderror
5. ZerodivisionError
6. Nometoderror
7. Indexerror
8. NameError
9. TAYEERROR

E altro.

Per sollevare e gestire un tipo di errore specifico, possiamo passarlo al blocco di sollevamento come parametro. Ecco un esempio:

inizio
RaccoldodivisionError
Rescue => Eccezione
mette l'eccezione.Messaggio
mette l'eccezione.backtrace.ispezionare
FINE

Nell'esempio sopra, solleviamo un ZerodivisionError. Saltiamo quindi nel blocco di salvataggio, che stampa il tipo di eccezione specifico e traccia la sorgente.

L'output risultante è:

$ Ruby Err-Handing.Rb
ZerodivisionError
["Err-Handing.RB: 2: in '' "]

Altri blocchi di eccezione

Oltre al blocco principale e di salvataggio, Ruby ci fornisce anche altri blocchi che possiamo implementare per gestire gli errori.

Loro includono:

Ritratta il blocco

Il blocco di riproduzione viene utilizzato per eseguire nuovamente il blocco di salvataggio dopo aver sollevato l'eccezione. Ecco un esempio:

inizio
Raccogli ZerodivisionError
mette "Non corro 😢"
Rescue => Eccezione
mette "#eccezione.messaggio mi ha fatto morire ⚰️ "
riprovare
FINE

Se eseguiamo il codice sopra, stamperà il messaggio all'interno del blocco di salvataggio. Incontrerà il blocco di riproduzione, che salta nel blocco di salvataggio.

Un caso di utilizzo comune di blocchi di pensionamento è la sondaggio di errori usando la forza bruta. Un esempio sarebbe quello di continuare a ricaricare una pagina quando la connessione non si risolve fino a quando l'errore si risolve.

ATTENZIONE: Fai attenzione quando si utilizza il blocco di riproduzione perché è una fonte comune di anelli infiniti.

Garantire il blocco

Se hai programmato in un altro linguaggio come Python, probabilmente hai familiarità con il blocco finalmente. Il blocco assicurativo in Ruby si comporta in modo simile al blocco finalmente in altri linguaggi di programmazione.

Il blocco assicurativo funziona sempre alla fine del codice. Indipendentemente dal fatto che l'eccezione rialzata sia stata gestita correttamente o l'esecuzione del programma termina, esegue sempre o esegue.

Ecco un esempio:

inizio
Raccogli ZerodivisionError
mette "Non corro 😢"
Rescue => Eccezione
mette "#eccezione.messaggio mi ha fatto morire ⚰️ "
garantire
mette "corro sempre 🚀"
FINE

In questo caso, il codice sopra stampa un messaggio di eccezione ed eseguirà infine il blocco assicurati.

ZerodivisionError mi ha fatto morire ⚰️
Corro sempre 🚀

Blocco altro

Se non viene sollevata alcuna eccezione, possiamo implementare un blocco per eseguire un'azione utilizzando l'istruzione else.

Per esempio:

inizio
Rescue => Eccezione
mette "#eccezione.messaggio mi ha fatto morire ⚰️ "
altro
mette "fidati di me, ho corso con successo 😀"
garantire
mette "e corro sempre 🚀"
FINE

Il blocco altro è posizionato tra il salvataggio e assicurarsi il blocco. Nell'esempio sopra, noterai che manca un blocco di aumento, che fa funzionare il blocco altro.

Ecco un esempio di esempio:

Fiducia Me, Ho corso con successo 😀

E corro sempre 🚀

Gestione delle eccezioni leggere

I blocchi di raccolta e salvataggio sono un modo utile per eseguire un'azione quando si verifica un errore. Tuttavia, poiché la gestione degli errori crea una traccia di stack per aiutare con il debug, può facilmente diventare problematico all'interno del programma. È qui che arrivano i blocchi di cattura e lancio.

Per implementare un blocco catch-Throw, si avvia definendo l'etichetta utilizzando la parola chiave Catch. Una volta che Ruby incontra un blocco di lancio che fa riferimento al blocco di cattura, interrompe l'esecuzione e salta al blocco di cattura.

Usiamo un esempio per illustrare questo concetto. Considera la nidificazione disordinata mostrata nel codice seguente:

catch (: kill_me_now) do
langs = ["Python", "Ruby", "C ++", "C#"]
foriinlangsdo
per indice in 1 ... 5
Se indice == 3
ifi == "c#"
mette "Dopo il lancio, non funzionerà nulla!'"
throw (: kill_me_now)
mette "I am c#"
FINE
FINE
FINE
FINE
FINE
mette "Oh ragazzo! È stato lungo!"

Iniziamo utilizzando la parola chiave Catch e passiamo l'etichetta all'interno di una coppia di parentesi. Una volta eseguito il codice, eseguirà tutti i loop nidificati e se le dichiarazioni fino a quando non incontra la dichiarazione di lancio che fa riferimento al catch.

Che terminerà immediatamente l'esecuzione ed uscirà al livello della dichiarazione di cattura.

Ecco un esempio di esempio:

Dopo il lancio, non funzionerà nulla!'
Oh ragazzo! È stato lungo!

Conclusione

Questo tutorial ti ha mostrato come implementare la gestione degli errori in Ruby usando i blocchi di raccolta e salvataggio.