try … catch (Fehlerbehandlung)

Wenn JavaScript-Code ausgeführt wird, dann wird von der auch von der „Laufzeit“ gesprochen. Zur Laufzeit können während der Ausführung verschiedene Fehler auftreten, die zu einer sofortigen Beendung des Programms führen (das Programm „stürzt ab“).

Eine Liste möglicher Fehler in JavaScript ist hier bei MDN zu finden.

Syntaxfehler

Syntaxfehler (syntax errors) entstehen, wenn der Programmcode syntaktisch inkorrekt ist, d.h. wenn der Code nicht richtig „formuliert“ wurde. Hier ein Beispiel für einen Syntaxfehler, bei der eine Zuweisung „vertauscht“ wurde:

3.14 = const pi;
// SyntaxError: Invalid left-hand side in assignment

Fehlerbehandlung

Bei anderen Fehlerarten kann durch eine sogenannte Fehlerbehandlung (error handling) zur Laufzeit dafür gesorgt werden, dass der Fehler nicht zum Programmabsturz führt und das Programm ein passendes Verhalten zum Umgang mit dem Fehler durch Programmcode umsetzt.

try…catch

Für die Fehlerbehandlung steht in JavaScript mit den Schlüsselwörtern try und catch ein geeignetes Konstrukt zur Verfügung:

try {
  // JavaScript-Code mit möglichen Fehlern
} catch(error) {
  // Fehlerbehandlung
}

Wenn in dem von try {…} umgebenen Block ein Fehler auftritt, der normalerweise zum Programmabsturz führt, dann wird in diesem Fall der Code im catch-Block fortgesetzt. Das Programm wird also nicht beendet. Außerdem wird dem catch-Block das Fehlerobjekt ähnlich wie bei einer Funktion als „Parameter“ übergeben (hier in den Beispielen error genannt).

Als Beispiel zur Verwendung von try…catch werden wir den Fehler TypeError betrachten, der gelegentlich im JavaScript-Code auftaucht.

TypeError (Beispiele)

Ein TypeError kann in unterschiedlichen Situationen auftreten und führt zu einem Programmabsturz:

const obj = {name: 'Joe'};
obj = 1; // Type-Error --> Programmabsturz!
// TypeError: Assignment to constant variable.
  
console.log(obj.getName()); // Type-Error --> Programmabsturz!
// TypeError: obj.getName is not a function
 
console.log(obj.age.print()); // Type-Error --> Programmabsturz!
// TypeError: Cannot read property 'print' of undefined

Soll vermieden werden, dass das Programm bei einem TypeError oder einem der anderen Laufzeitfehler beendet wird, dann kann der relevante Code mit einem try-Block umgeben und durch einen catch-Block ergänzt werden (jeweils umgeben von geschweiften Klammern):

try {
  const obj = {name: 'Joe'};
  obj = 1; // TypeError !
  // --> Ausführung "springt" zum catch-Block
  // usw.
} catch(error) {
  console.error(error); 
  // TypeError: Assignment to constant variable.
  // ggf. weitere Fehlerbehandlung
  // Programm wird nicht beendet und kann weiter ablaufen…
}
console.log('Programm läuft weiter…');

Oftmals ist es hilfreich, das Fehlerobjekt auszugeben, wie oben in catch zu sehen (z.B. mit console.error).

finally

Zusätzlich kann ein Block mit finally deklariert werden, der immer nach der Ausführung des Codes in try auftritt — unabhängig davon on ein Fehler in catch behandelt wurde oder nicht:

try {
  // JavaScript-Code mit möglichen Fehlern
} catch(error) {
  // Fehlerbehandlung
} finally {
  // Dieser Code wird abschließend ausgeführt
  // Auch wenn der catch-Block nicht aktiv wurde!
}

Das Prinzip der Ausnahmebehandlung gibt es in vielen anderen Programmiersprachen. Oft ähnelt das Konzept dem oben beschriebenen Ansatz mit try … catch und finally.

Eigene Fehler mit throw

Im Programmcode können auch eigene Fehler erzeugt werden. Dazu ist das Schlüsselwort throw bestimmt, mit dem Fehler erzeugt werden:

function divide(a,b) {
  if(b===0) {
    throw new Error('not allowed to divide by 0!');
  }
  return a/b;
}
 
try {
  const result = divide(1000,0);
  console.log(result);
} catch(error) {
  console.error(error);
}

Mit throw werden Fehler also „geworfen“, um diese an anderer Stelle wiederum mit catch „aufzufangen“. Eigene Fehler werden mit passenden Meldungen durch new Error(msg) erstellt.