Fehlschläge können beängstigend sein, sind aber ein wichtiger Teil der Programmierung. Du kannst Fehlschläge nutzen, um zu lernen, wie man debuggt, um die Grenzen eines Programms zu finden oder um schnell zu sehen, was man nicht tun sollte!
Fehlschläge sind okay
In Verse bezeichnet der Begriff Fehlschlag etwas ganz Bestimmtes. Er zeigt nicht unbedingt immer an, dass etwas nicht funktioniert hat. Du kannst damit kontrollieren, was dein Programm tut.
Weißt du noch, wie du in Lektion 4 gelernt hast, dass du Code schreiben kannst, um eine ja oder nein Frage zu stellen?
var Tired: logic = false
var WhatToWatch: string = "nothing"
if (Tired?):
set WhatToWatch = "your eyelids"
else:
set WhatToWatch = "cartoons"
Print(“You should watch {WhatToWatch}”)
# Du solltest Cartoons schauen
Der Code, der die Frage stellt, ist als fehlbarer Ausdruck geschrieben. Im obigen Beispiel ist Tired?
ein fehlbarer Ausdruck.
Fehlbare Ausdrücke werden verwendet, um Fehler zu vermeiden, die dazu führen könnten, dass dein Programm überhaupt nicht mehr funktioniert. Bestimmt weißt du, dass eine Division durch Null unmöglich ist. Wenn du versuchst, in deinem Code durch Null zu teilen, könnte er abstürzen! Der folgende Verse-Code funktioniert jedoch einwandfrei.
if (5/0):
Print("Oops!")
else:
Print("Das ist nicht erlaubt!")
Um diese Art von Fehlern zu vermeiden, verlangt Verse, dass du fehlbare Ausdrücke in einen Fehlerkontext schreibst. Fehlerkontexte geben fehlbaren Ausdrücken einen sicheren Ort zum Fehlschlagen. Im obigen Beispiel war 5/0
der fehlbare Ausdruck und if()
der Fehlerkontext. Im folgenden Abschnitt werden wir diese beiden Verse-Konzepten näher erläutern.

Fehlbare Ausdrücke
Es gibt viele Möglichkeiten, fehlbare Ausdrücke in Verse zu schreiben. Wenn ein Ausdruck eine Ja- oder Nein-Frage enthält, ist er wahrscheinlich fehlbar.
Im Folgenden sind einige Arten von Fragen aufgeführt, die mit fehlbaren Ausdrücken gestellt werden:
- Ist diese Variable größer als, kleiner als oder gleich dieser anderen Variable?
- Ist diese Variable auf
true
gesetzt? - Ist diese Variable auf einen Wert gesetzt?
- Verursacht dieser Ausdruck einen Fehler?
Wenn die Antwort auf eine dieser Fragen ja lautet, ist der Ausdruck erfolgreich. Wenn die Antwort nein lautet, ist der Ausdruck fehlgeschlagen. Was nach einem Erfolg oder Fehlschlag geschieht, hängt davon ab, wie du deinen Code schreibst.
Vergleichsausdrücke
Vergleichsausdrücke, die Vergleichsoperatoren wie <
(kleiner als), ` > (größer als) oder
<> (ungleich) verwenden, sind fehlbar. Im folgenden Beispiel ist
5 < 4` ein fehlbarer Ausdruck, der fehlschlagen wird:
if (5 < 4):
Print(“Dieser Satz wird nie gedruckt.”)
Der Ausdruck 5 < 4
ist wie die Frage "Ist 5 kleiner als 4?". Die Antwort ist nein, der Ausdruck schlägt fehl, und der Codeblock (eingerückt unter dem if
-Ausdruck) wird nicht ausgeführt.
Betrachten wir das nächste Beispiel und den fehlbaren Ausdruck MousetrapsSet <> MiceCaught
. Die Frage lautet: "Sind die Werte von MousetrapsSet und MiceCaught ungleich?".
MousetrapsSet := 3
MiceCaught := 0
if (MousetrapsSet<>MiceCaught):
Print(“Wir brauchen mehr Käse!”)
Diesmal lautet die Antwort auf die Frage Ja, weil MousetrapsSet
gleich 3 und MiceCaught
gleich 0 ist, sodass der Ausdruck erfolgreich ist und der Codeblock ausgeführt wird.
Entscheidungsausdrücke
Entscheidungsausdrücke, die die Operatoren and
, or
und not
verwenden, sind fehlbar. Im folgenden Beispiel ist MousetrapsForSale > 0 and Coins >= MousetrapCost
ein fehlbarer Ausdruck, der erfolgreich ist, weil MousetrapsForSale
5 ist (größer als 0), Coins
30 und MousetrapCost
20 (30 ist größer als 20). Beide Ausdrücke sind für sich genommen erfolgreich, so dass der gesamte Ausdruck erfolgreich ist.
MousetrapsForSale := 5
MousetrapCost := 20
Coins := 30
if (MousetrapsForSale > 0 and Coins >= MousetrapCost):
Print(“Du kannst Mausefallen kaufen.”)
Query-Ausdrücke
Query-Ausdrücke sind ebenfalls fehlbar. Sie verwenden den ?
-Operator, um bestimmte Werte zu prüfen, z. B. ob ein logischer
Wert true
ist. Im folgenden Beispiel ist MousetrapStoreOpen?
ein fehlbarer Ausdruck, der fehlschlägt, weil MousetrapStoreOpen
false
ist.
var MousetrapStoreOpen : logic = false
if (MousetrapStoreOpen?):
Print(“Hereinspaziert!”)
Fehlerkontexte
In allen obigen Codebeispielen war der if
-Ausdruck der Fehlerkontext für die in den Klammern ()
enthaltenen fehlbaren Ausdrücke. Fehlerkontexte geben fehlbaren Ausdrücken einen sicheren Ort, an dem sie fehlschlagen können, da sie festlegen, was im Falle eines Fehlers geschieht.
Du weißt bereits aus einer früheren Lektion, dass, wenn ein Ausdruck in einem if
fehlschlägt, der Code innerhalb des if
-Codeblocks nicht ausgeführt wird.
Da if
einen Fehlerkontext erzeugt, kannst du so viele fehlbare Ausdrücke in seinen Codeblock einfügen, wie du willst. Wenn einer dieser Ausdrücke fehlschlägt, werden die früheren Ausdrücke des Codeblocks rückgängig gemacht oder zurückgerollt.
Es gibt noch eine andere Möglichkeit, if
-Ausdrücke zu schreiben, ohne die Klammern ()
zu verwenden. Sie ist nützlicher, wenn du eine Menge Ausdrücke schreiben musst. Hier ist ein Beispiel:
MousetrapsSet:int = 5
var MiceCaught:int = 0
var BreakTime:logic = false
if:
MousetrapsSet > 0
set BreakTime = true
MiceCaught > 0
if (BreakTime?):
Print("Mach mal Pause!")
else:
Print("Fang ein paar Mäuse!")
In einem Fehlerkontext müssen nicht alle Ausdrücke fehlbar sein, aber mindestens einer muss fehlbar sein. Im obigen Beispiel ist set BreakTime = true
nicht fehlbar, die anderen Ausdrücke jedoch schon.
Im obigen Code befindet sich jeder unter if
eingerückte Ausdruck innerhalb des Fehlerkontextes. Alle drei Ausdrücke werden ausgeführt.
MousetrapsSet > 0
wird erfolgreich sein.- Der Ausdruck
set BreakTime = true
wird ausgeführt. Er ist nicht fehlbar, so dass es keine Fehlerprüfung gibt. MiceCaught > 0
wird jedoch fehlschlagen.
Da ein Fehlschlag auftrat, wird jeder Ausdruck im if
-Codeblock zurückgesetzt, einschließlich set BreakTime = true
. Es wird so sein, als wäre der Code nie gelaufen. Wenn du diesen Code ausführst, siehst du, dass "Catch some mice!" gedruckt wird.
Beim Programmieren wirst du feststellen, dass viele Codes nur funktionieren, wenn andere Codes erfolgreich laufen. Dies ist ein weiterer Grund, warum Fehlerkontexte so nützlich sind. Wenn du abhängigen Code in Fehlerkontexten gruppierst, kannst du einige häufige Fehler vermeiden. Erinnerst du dich an den Code, den du in Lektion 4 benutzt hast, um zu entscheiden, ob du ins Kino gehen willst? Jetzt, wo du dich entschieden hast, mit deinen Freunden zu gehen, musst du ihnen die Tickets, Getränke und Snacks besorgen!
var Drinks:int = 4
var Snacks:int = 4
var Tickets:int = 3
var FriendsAvailable:int = 4
if:
Drinks >= FriendsAvailable
set Drinks -= FriendsAvailable
Snacks >= FriendsAvailable
set Snacks -= FriendsAvailable
Tickets >= FriendsAvailable
set Tickets -= FriendsAvailable
Print("Getränke übrig: { Drinks }")
Print("Snacks übrig: { Snacks }")
Print("Eintrittskarten übrig: { Tickets }")
Der Operator -=
ist eine Abkürzung für die Kombination von Subtraktion und Zuweisung. Im obigen Beispiel ist set Tickets -= FriendsAvailable
gleichbedeutend mit set Tickets = Tickets - FriendsAvailable
. Dies funktioniert auch mit Addition (+=
), Multiplikation (*=
) und Division (/=
).
Du hast genug Getränke und Snacks für deine Freunde dabei, aber nicht genug Eintrittskarten. Das bedeutet, dass du und alle deine Freunde den Film nicht sehen können. Du könntest einen Code schreiben, um diese Situation zu bewältigen, aber du willst wahrscheinlich nicht deine Getränke und Snacks herausgeben.
Glücklicherweise schlägt der Ausdruck Tickets >= FriendsAvailable
fehl, und der gesamte Code im if
-Block wird zurückgesetzt. Das bedeutet, dass die Variablen Drinks
und Snacks
beide wieder den Wert 4
haben werden.
Zusammenfassung
- In Verse sind Fehlschläge eine Möglichkeit, dein Programm zu kontrollieren. Fehlbare Ausdrücke können entweder erfolgreich sein oder fehlschlagen, und sie müssen in einem Fehlerkontext geschrieben werden. Was nach einem Erfolg oder Misserfolg geschieht, hängt davon ab, wie dein Code geschrieben ist.
- Fehlerkontexte geben Fehlerausdrücken einen sicheren Ort, an dem sie fehlschlagen können. Jeder Fehler innerhalb eines Fehlerkontextes führt dazu, dass der gesamte Code innerhalb dieses Kontextes zurückgerollt wird, als ob er nie gelaufen wäre.