try {  tryStatements} catch (exceptionVar) {  catchStatements} finally {  finallyStatements}

tryStatements

Die Anweisungen, die ausgeführt werden sollen.

catchStatements

Anweisung, die ausgeführt wird, wenn imtry-Block eine Ausnahme ausgelöst wird.

exceptionVarOptional

Ein optionalerIdentifier oder ein Muster, um die gefangene Ausnahme für den zugehörigencatch-Block zu halten. Wenn dercatch-Block den Wert der Ausnahme nicht verwendet, können SieexceptionVar und seine umgebenden Klammern weglassen.

finallyStatements

Anweisungen, die ausgeführt werden, bevor der Kontrollfluss dietry...catch...finally-Konstruktion verlässt. Diese Anweisungen werden ausgeführt, unabhängig davon, ob eine Ausnahme ausgelöst oder gefangen wurde.

Dietry-Anweisung beginnt immer mit einemtry-Block. Dann muss eincatch-Block oder einfinally-Block vorhanden sein. Es ist auch möglich, sowohlcatch- als auchfinally-Blöcke zu haben. Dies gibt uns drei Formen für dietry-Anweisung:

• try...catch
• try...finally
• try...catch...finally

Im Gegensatz zu anderen Konstruktionen wieif oderfor müssen dietry,catch undfinally-BlöckeBlöcke und keine einzelnen Anweisungen sein.

try doSomething(); // SyntaxErrorcatch (e) console.log(e);

Eincatch-Block enthält Anweisungen, die angeben, was zu tun ist, wenn imtry-Block eine Ausnahme ausgelöst wird. Wenn eine Anweisung imtry-Block (oder in einer Funktion, die aus demtry-Block aufgerufen wird) eine Ausnahme auslöst, wird der Kontrollfluss sofort auf dencatch-Block verlagert. Wenn imtry-Block keine Ausnahme ausgelöst wird, wird dercatch-Block übersprungen.

Derfinally-Block wird immer ausgeführt, bevor der Kontrollfluss dietry...catch...finally-Konstruktion verlässt. Er wird immer ausgeführt, unabhängig davon, ob eine Ausnahme ausgelöst oder gefangen wurde.

Sie können ein oder mehreretry-Anweisungen verschachteln. Wenn eine inneretry-Anweisung keinencatch-Block hat, wird dercatch-Block der umschließendentry-Anweisung stattdessen verwendet.

Sie können dietry-Anweisung auch verwenden, um JavaScript-Ausnahmen zu behandeln. Weitere Informationen zu JavaScript-Ausnahmen finden Sie imJavaScript-Leitfaden.

Wenn imtry-Block eine Ausnahme ausgelöst wird, hältexceptionVar (d.h. dase incatch (e)) den Ausnahme-Wert. Sie können dieseBindung verwenden, um Informationen über die ausgelöste Ausnahme zu erhalten. DieseBindung ist nur imGültigkeitsbereich descatch-Blocks verfügbar.

Es muss kein einzelner Bezeichner sein. Sie können einDestrukturierungsmuster verwenden, um mehrere Bezeichner gleichzeitig zuzuweisen.

try {  throw new TypeError("oops");} catch ({ name, message }) {  console.log(name); // "TypeError"  console.log(message); // "oops"}

Die durch diecatch-Klausel erstellten Bindungen existieren im selben Gültigkeitsbereich wie dercatch-Block, daher können imcatch-Block deklarierte Variablen nicht denselben Namen wie die durch diecatch-Klausel erstellten Bindungen haben. (Es gibteine Ausnahme von dieser Regel, aber es handelt sich um eine veraltete Syntax.)

try {  throw new TypeError("oops");} catch ({ name, message }) {  var name; // SyntaxError: Identifier 'name' has already been declared  let message; // SyntaxError: Identifier 'message' has already been declared}

Die Ausnahmebindung ist beschreibbar. Beispielsweise könnten Sie den Ausnahme-Wert normalisieren, um sicherzustellen, dass es sich um einError-Objekt handelt.

try {  throw "Oops; this is not an Error object";} catch (e) {  if (!(e instanceof Error)) {    e = new Error(e);  }  console.error(e.message);}

Wenn Sie den Ausnahme-Wert nicht benötigen, können Sie ihn zusammen mit den umschließenden Klammern weglassen.

function isValidJSON(text) {  try {    JSON.parse(text);    return true;  } catch {    return false;  }}

Derfinally-Block enthält Anweisungen, die nach der Ausführung destry-Blocks undcatch-Blocks ausgeführt werden, jedoch vor den Anweisungen, die demtry...catch...finally-Block folgen. Der Kontrollfluss wird denfinally-Block immer betreten, was auf eine der folgenden Weisen geschehen kann:

• Unmittelbar nachdem dertry-Block die Ausführung normal beendet hat (und keine Ausnahmen wurden ausgelöst);
• Unmittelbar nachdem dercatch-Block die Ausführung normal beendet hat;
• Unmittelbar bevor die Ausführung einer Kontrollflussanweisung (return,throw,break,continue) imtry-Block odercatch-Block erfolgt, die den Block verlassen würde.

Wenn eine Ausnahme aus demtry-Block ausgelöst wird, selbst wenn keincatch-Block vorhanden ist, um die Ausnahme zu behandeln, wird derfinally-Block trotzdem ausgeführt, wobei die Ausnahme sofort nach dem Abschluss desfinally-Blocks erneut ausgelöst wird.

Das folgende Beispiel zeigt einen Anwendungsfall für denfinally-Block. Der Code öffnet eine Datei und führt dann Anweisungen aus, die die Datei verwenden; derfinally-Block stellt sicher, dass die Datei immer geschlossen wird, nachdem sie verwendet wurde, selbst wenn eine Ausnahme ausgelöst wurde.

openMyFile();try {  // tie up a resource  writeMyFile(theData);} finally {  closeMyFile(); // always close the resource}

Kontrollflussanweisungen (return,throw,break,continue) imfinally-Block werden jeden Abschlusswert destry-Blocks odercatch-Blocks "maskieren". In diesem Beispiel versucht dertry-Block, 1 zurückzugeben, aber bevor die Rückgabe erfolgt, wird der Kontrollfluss zuerst demfinally-Block zugeführt, sodass der Rückgabewert desfinally-Blocks stattdessen zurückgegeben wird.

function doIt() {  try {    return 1;  } finally {    return 2;  }}doIt(); // returns 2

Es ist generell eine schlechte Idee, Kontrollflussanweisungen imfinally-Block zu verwenden. Verwenden Sie ihn nur für Bereinigungscode.

Wenn eincatch-Block verwendet wird, wird dercatch-Block ausgeführt, wenn eine Ausnahme von innerhalb destry-Blocks ausgelöst wird. Beispielsweise, wenn die Ausnahme im folgenden Code auftritt, wird der Kontrollfluss auf dencatch-Block übertragen.

try {  throw new Error("My exception"); // generates an exception} catch (e) {  // statements to handle any exceptions  logMyErrors(e); // pass exception object to error handler}

Dercatch-Block gibt einen Bezeichner an (e im obigen Beispiel), der den Wert der Ausnahme hält; dieser Wert ist nur imGültigkeitsbereich descatch-Blocks verfügbar.

Sie können "Bedingtecatch-Blöcke" erstellen, indem Sietry...catch-Blöcke mitif...else if...else-Strukturen kombinieren, wie folgt:

try {  myRoutine(); // may throw three types of exceptions} catch (e) {  if (e instanceof TypeError) {    // statements to handle TypeError exceptions  } else if (e instanceof RangeError) {    // statements to handle RangeError exceptions  } else if (e instanceof EvalError) {    // statements to handle EvalError exceptions  } else {    // statements to handle any unspecified exceptions    logMyErrors(e); // pass exception object to error handler  }}

Ein häufiger Anwendungsfall besteht darin, nur eine kleine Teilmenge der erwarteten Fehler zu erfassen (und zu unterdrücken) und den Fehler in anderen Fällen erneut auszulösen:

try {  myRoutine();} catch (e) {  if (e instanceof RangeError) {    // statements to handle this very common expected error  } else {    throw e; // re-throw the error unchanged  }}

Dies kann die Syntax aus anderen Sprachen wie Java nachahmen:

try {  myRoutine();} catch (RangeError e) {  // statements to handle this very common expected error}// Other errors are implicitly re-thrown

Zuerst, sehen wir, was in diesem Fall passiert:

try {  try {    throw new Error("oops");  } finally {    console.log("finally");  }} catch (ex) {  console.error("outer", ex.message);}// Logs:// "finally"// "outer" "oops"

Nun, wenn wir die Ausnahme bereits im innerentry-Block gefangen haben, indem wir einencatch-Block hinzufügen:

try {  try {    throw new Error("oops");  } catch (ex) {    console.error("inner", ex.message);  } finally {    console.log("finally");  }} catch (ex) {  console.error("outer", ex.message);}// Logs:// "inner" "oops"// "finally"

Und jetzt werfen wir den Fehler erneut.

try {  try {    throw new Error("oops");  } catch (ex) {    console.error("inner", ex.message);    throw ex;  } finally {    console.log("finally");  }} catch (ex) {  console.error("outer", ex.message);}// Logs:// "inner" "oops"// "finally"// "outer" "oops"

Eine gegebene Ausnahme wird nur einmal von dem nächstgelegenen umschließendencatch-Block gefangen, es sei denn, sie wird erneut ausgelöst. Natürlich werden alle neuen Ausnahmen, die im "inneren" Block ausgelöst werden (weil der Code imcatch-Block etwas tun kann, das ein Auslösen verursacht), vom "äußeren" Block gefangen.

Wenn derfinally-Block einen Wert zurückgibt, wird dieser Wert zum Rückgabewert der gesamtentry-catch-finally-Anweisung, unabhängig von allenreturn-Anweisungen in dentry undcatch-Blöcken. Dies schließt Ausnahmen ein, die innerhalb descatch-Blocks ausgelöst werden:

(() => {  try {    try {      throw new Error("oops");    } catch (ex) {      console.error("inner", ex.message);      throw ex;    } finally {      console.log("finally");      return;    }  } catch (ex) {    console.error("outer", ex.message);  }})();// Logs:// "inner" "oops"// "finally"

Der äußere "oops" wird nicht ausgelöst, weil die Rückgabe imfinally-Block erfolgt. Dasselbe gilt für jeden Wert, der vomcatch-Block zurückgegeben wird.

• Error
• throw