Ausnahmebehandlung in Ruby

Ausnahmebehandlung bezieht. Ein Fehler bezieht sich in den meisten Fällen auf ein unerwartetes Ereignis oder Ereignis während der Ausführung des Programms. Beispielsweise kann ein Fehler auftreten, wenn eine Datei entweder aufgrund der nicht vorhandenen Datei gelesen wird oder der Benutzer nicht die richtige Berechtigung zum Lesen oder Schreiben in die Datei hat.

In diesem Tutorial werden Ihnen angezeigt.

Grundnutzung

Die meisten Programmiersprachen implementieren Ausnahmebehandlung mit dem Try -and -Catch -Block. Wie bei allem anderen in Ruby sind die Schlüsselwörter jedoch beschreibender.

Wir können die allgemeine Syntax wie unten gezeigt ausdrücken:

Start
Raisexception
# Ecxception erhöhen
Rettungsausnahme
# Rettungsblock
Ende

Wir schließen den Ausnahmebeherrandblock in einer Start- und Endanweisung ein. In diesen Aussagen definieren wir die Erhöhungs- und Rettungsblöcke.

In der Erhöhung definieren wir die Ausnahme, die wir manuell heben oder den Ruby -Dolmetscher generieren lassen können. Standardmäßig ist der Parameter für den Erhöhungsblock RunTimeError

Als nächstes kommt der Rettungsblock. Wie der Name schon sagt, kommt dieser Block zur Rettung, wenn eine Ausnahme auftritt. Es übernimmt die Kontrolle über die Ausführung des Programms.

Ruby wird die Ausnahme vergleichen, die aus dem Erhöhungsblock mit den an den Rettungsblock übergebenen Parametern ausgelöst wird. Wenn die Ausnahme vom gleichen Typ oder einer Superklasse ausgeht, löst sie den Rettungsblock aus.

Beispiel für die Ausnahmehandhabung in Ruby

Wir können ein einfaches Beispiel implementieren, um zu veranschaulichen, wie die Ausnahmehandhabung in Ruby funktioniert:

def er_me
Start
setzt "Hallo dort!"
Erhöhen Sie "String -Typ"
Rettung
Setzt "Egal, ich bin repariert!"
Ende
Ende
Err_me

Im obigen Beispiel definieren wir eine Funktion mit einem Ausnahmeblock.

Wir stellen manuell eine Ausnahme an, die den Ausführungsfluss des Programms unterbricht und in den Rettungsblock eintritt. Dies führt die Aktionen im Block-in in diesem Fall aus, eine Put-Erklärung und Ausgabe.

Wenn Sie einen Codeblock unmittelbar nach der Erhöhung und vor dem Rettungsblock hinzufügen, werden sie nicht ausgeführt, da der Rettungsblock den Programmfluss sofort behandelt.

Standardmäßig verwendet der Rettungsblock den StandardError -Parameter. Es gibt jedoch andere Arten von Fehlern in Ruby, einschließlich.

1. Syntax-Fehler
2. IoError
3. Regexperror
4. ThreadError
5. NulodivisionError
6. Nomethoderror
7. IndexError
8. NameError
9. Typeerror

Und mehr.

Um einen bestimmten Fehlertyp zu erhöhen und zu behandeln, können wir ihn als Parameter an den Erhöhungsblock übergeben. Hier ist ein Beispiel:

Start
RaisezerodivisionError
rettung => Ausnahme
macht Ausnahme.Nachricht
macht Ausnahme.Backtrace.prüfen
Ende

Im obigen Beispiel erheben wir einen ZerodivisionError. Wir springen dann in den Rettungsblock, der den spezifischen Ausnahmetyp druckt und die Quelle verfolgt.

Die resultierende Ausgabe ist:

$ Ruby Err-Handling.rb
NulodivisionError
["Fehlerhandling.RB: 2: in '' "]

Andere Ausnahmeblöcke

Neben dem Haupthöhungs- und Rettungsblock bietet Ruby uns auch andere Blöcke, die wir implementieren können, um Fehler zu behandeln.

Sie beinhalten:

Block wiederholen

Der Wiederholungsblock wird verwendet, um den Rettungsblock nach der Erhöhung der Ausnahme erneut auszuführen. Hier ist ein Beispiel:

Start
ZeroodiVisionError erhöhen
Setzt "Ich renne nicht 😢"
rettung => Ausnahme
stellt "#Ausnahme.Nachricht ließ mich sterben ⚰️ "
wiederholen
Ende

Wenn wir den obigen Code ausführen, wird die Nachricht im Rettungsblock aus gedruckt. Es wird auf den Wiederholungsblock stoßen, der in den Rettungsblock springt.

Ein häufiger Anwendungsfall von Wiederholungsblöcken ist die Prüfung von Fehlern mit Brute Force. Ein Beispiel wäre es, eine Seite weiterzuladen, wenn die Verbindung heruntergefallen ist, bis der Fehler auflöst.

VORSICHT: Seien Sie vorsichtig, wenn Sie den Wiederholungsblock verwenden, da er eine häufige Quelle für unendliche Schleifen ist.

Block sicherstellen

Wenn Sie in einer anderen Sprache wie Python programmiert haben, sind Sie wahrscheinlich mit dem endgültigen Block vertraut. Der Block in Ruby erbringt ähnlich wie der endgültige Block in anderen Programmiersprachen.

Der Block für die Gewährleistung läuft immer am Ende des Codes. Unabhängig davon, ob die erhöhte Ausnahme korrekt behandelt wurde oder die Programmausführung endet, wird immer ausgeführt oder ausgeführt.

Hier ist ein Beispiel:

Start
ZeroodiVisionError erhöhen
Setzt "Ich renne nicht 😢"
rettung => Ausnahme
stellt "#Ausnahme.Nachricht ließ mich sterben ⚰️ "
sicherstellen
Setzt "Ich werde immer 🚀 rennen"
Ende

In diesem Fall druckt der obige Code eine Ausnahmebegeldung und führt schließlich den Block sicher aus.

ZerodivisionError hat mich dazu gebracht, ⚰️ zu sterben
Ich werde immer rennen 🚀

Sonst block

Wenn keine Ausnahme erhöht wird, können wir einen Block implementieren, um eine Aktion mithilfe der sonstigen Anweisung auszuführen.

Zum Beispiel:

Start
rettung => Ausnahme
stellt "#Ausnahme.Nachricht ließ mich sterben ⚰️ "
anders
Setzt "Vertrauen Sie mir, ich habe erfolgreich 😀 gelaufen."
sicherstellen
setzt "& ich werde immer 🚀 rennen"
Ende

Der else -Block wird zwischen der Rettung und dem Sicherungsblock platziert. Im obigen Beispiel werden Sie feststellen.

Hier ist ein Beispielausgang:

Vertrauen Mich, Ich lief erfolgreich 😀

& Ich werde immer rennen 🚀

Leichte Ausnahmehandling

Die Erhöhungs- und Rettungsblöcke sind eine praktische Möglichkeit, eine Aktion auszuführen, wenn ein Fehler auftritt. Da jedoch Fehlerbehandlungen eine Stapelverfolgung entwickelt, um beim Debuggen zu helfen, kann dies in Ihrem Programm leicht problematisch werden. Hier kommen die Fang- und Wurfblöcke ins Spiel.

Um einen Catch-Throw-Block zu implementieren, beginnen Sie zunächst das Etikett mithilfe des Catch-Keywords. Sobald Ruby auf einen Wurfblock trifft, der auf den Fangblock verweist, stoppt er die Ausführung und springt zum Fangblock springt.

Lassen Sie uns ein Beispiel verwenden, um dieses Konzept zu veranschaulichen. Betrachten Sie die im folgende Code angezeigte chaotische Verschachtelung:

catch (: Kill_me_now) tun
Langs = ["Python", "Ruby", "C ++", "C#"]
Foriinlangsdo
für Index in 1… 5
Wenn Index == 3
ifi == "C#"
stellt "nach dem Wurf wird nichts laufen!'"
throw (: Kill_me_now)
Setzt "Ich bin c#"
Ende
Ende
Ende
Ende
Ende
Setzt "Oh Junge! Das war lang!"

Wir beginnen mit dem Catch -Keyword und übergeben das Etikett in einem Paar Klammern. Sobald wir den Code ausgeführt haben, werden alle verschachtelten Schleifen ausgeführt und wenn Aussagen, bis er auf die Wurfanweisung auf den Fang bezieht.

Dadurch werden die Ausführungen und geben sofort auf die Ebene der Catch -Anweisung zurück.

Hier ist ein Beispielausgang:

Nach dem Wurf wird nichts laufen!''
Oh Junge! Das war lang!

Abschluss

Dieses Tutorial hat Ihnen gezeigt.