1. Startseite
2. JavaScript
3. Umgang mit Fehler

Umgang mit Fehler

Immer wieder kommt es vor, dass der User nicht die Eingaben tätigt, die getätigt werden sollen.

Neben den Eingeben falscher Werte, wie zum Beispiel anstelle von Number wird ein String eingegeben, gibt es noch verschiedene Typen von Fehler.

Syntaxfehler

Syntaxfehler sind Fehler, die durch einen "guten Texteditor" bereits im Vorfeld erkannt werden.

Das sind Fehler wie falsch geschriebene Schlüsselwörter oder vergessene Klammern oder andere Sonderzeichen. Der Interpreter wird im Programmdurchlauf auch auf den Fehler mit entsprechender Zeilennummer hinweisen, damit dieser schnell korrigiert werden kann.

Laufzeitfehler

Laufzeitfehler sind die Fehler, die erst während der Programmausführung auftreten, weil zum Beispiel auf den Wert einer Variable zugegriffen werden soll, der noch nicht deklariert wurde.

Logische Fehler

Logische Fehler entstehen durch falsche Logik.

Wenn zum Beispiel in einem Programm alle nicht positiven Zahlen, also alle Zahlen mit einem – vor dem Wert, einem Buchstaben M wie Minus zugewiesen bekommen. Und alle Zahlen mit einem positiven Wert also ohne Minuszeichen vor dem Wert, ein P wie Positiv zugewiesen bekommen, dann könnte man schreiben.

let wert = f => {
 if(f<0) {
  wert = 'N'
 }
 if(f>0) {
  wert = 'P'
 }
 return wert;
}

Nur liegt hier der logische Fehler, wenn die 0 eingegeben wird. Für diesen Fall gibt es keine Zuweisung. Das ist bis hier kein Problem, kann aber für die Weiterverarbeitung ein Problem werden. Denn dieser Fehler kann erst an einer anderen Stelle im Programm auftreten und ist nicht direkt zuzuordnen. Dadurch sind Logik Fehler am schwierigsten aufzuspüren.

Fehler abfangen

Die Ausnahmebehandlung mit "try" und "catch" ermöglicht es, das Programm vor einem Absturz zu bewahren.

Wenn wir davon ausgehen können das an bestimmten Stellen aufgrund falscher Benutzereingaben oder anderem Ursachen Fehler auftreten können, dann setzen wir diesen Code in einem "try"-Block. Wenn hier tatsächlich ein Fehler auftritt, dann verzweigt das Programm in einem "catch"-Block, wo der Fehler gefangen wird. Hier können wir Fehlermeldungen ausgeben oder andere Anweisungen durchlaufen, um die Folgen des Fehlers zu neutralisieren. Falls kein Fehler auftritt, wird der "catch"-Block auch nicht verarbeitet. Zudem kann auch noch ein "finally"-Block erstellt werden der wird dann in jedem Fall durchlaufen, egal ob es einen Fehler gab oder nicht. Das Schlüsselwort "try" leitet einen Codeblock mit geschweiften Klammern ein, in dem der Code steht, der Fehler auswerfen könnte.

let bb = 40;
try {
 console.log(bc);
}

In diesem Fall wollen wir die Variable bc ausgeben, die aber nicht existiert. Der Fehler wird bemerkt und das Programm verzweigt in den "catch"-Block. Jetzt wird der Fehler in ein Fehlerobjekt gespeichert, welches wir hier mit "e" wie "error" bezeichnen. Der Name ist aber frei wählbar.

catch(e) {
 alert(e);
}

Hier können wir auf Fehler reagieren oder Sie wie im Beispiel einfach nur ausgeben lassen. "try" bedeutet übersetzt so viel wie versuchen, und "catch" so viel wie fangen. Also haben wir einen Versuchsblock und einen Block zum Abfangen, wenn was schief läuft. Optional kann der "finally"-Block angefügt werden, er wird in jedem Fall ausgewertet.

finally(e) {
 console.log('Ich werde immer verarbeitet');
}

Mit "throw" können wir auch auf fehlerhafte Eingaben reagieren und direkt auf den "catch"-Block verzweigen.

Im Beispiel soll der Benutzer eine positive Zahl eingeben. Wenn er eine Zahl eingibt, die nicht Positiv ist oder überhaupt keine Zahl eingibt, dann wird er die entsprechende Meldung erhalten.

let wert = parseFloat(prompt('Bitte eine positive Zahl eingeben.'))
try {
 if(isNaN(wert))
  throw 'Das ist keine gültige Zahl.';
 if(wert < 0)
  throw wert + ' ist kleiner als 0';
 console.log(wert);
}
catch(error) {
 alert(error);
}

Nach der Usereingabe wir durch "parseFloat" geprüft, ob aus der Eingabe eine gültige Zahl konvertiert werden kann, sollte das nicht der Fall sein, dann wird der Wert "NAN" (Not a Number) zurückgegeben und die Meldung "Das ist keine gültige Zahl" erscheint auf dem Bildschirm. Wenn die Eingabe doch eine gültige Zahl darstellt, wird geprüft, ob sie größer oder gleich 0 ist. Sollte die Zahl kleiner sein, dann wird wieder die entsprechende Meldung ausgegeben. Wenn das Programm an einem "throw" gelangt ist, so wird es angehalten und die Anweisungen nach dem "throw" werden nicht mehr ausgeführt. Die Programmausführung wird an den nächsten "catch"-Block weiter geleitet. Wenn innerhalb einer Funktion der Fehler nicht gefangen wird, so springt der Interpreter aus der Funktion raus. Wenn es eine Funktion gibt, die wiederum eine zweite Funktion aufruft und in der zweiten Funktion ein Fehler auftritt und in dieser zweiten Funktion wird der Fehler nicht aufgefangen, so springt der Interpreter aus der zweiten Funktion raus und prüft, ob der Fehler in der ersten Funktion aufgefangen wird. Wenn es hier einen "catch"-Block gibt, wird der Interpreter ab dieser Stelle die Arbeit wieder aufnehmen. Falls kein "catch"-Block definiert wurde, wird das gesamte Programm beendet.