try...catch

Probieren Sie es aus

try {
  nonExistentFunction();
} catch (error) {
  console.error(error);
  // Expected output: ReferenceError: nonExistentFunction is not defined
  // (Note: the exact output may be browser-dependent)
}

Syntax

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

tryStatements

Die Anweisungen, die ausgefhrt werden sollen.

catchStatements

Anweisung, die ausgefhrt wird, wenn im try Block eine Ausnahme ausgelst wird.

exceptionVar Optional

Ein optionaler Identifier oder ein Muster zum Halten der gefangenen Ausnahme fr den zugehrigen catch Block. Wenn der catch Block den Wert der Ausnahme nicht verwendet, knnen Sie exceptionVar und seine umgebenden Klammern weglassen.

finallyStatements

Anweisungen, die ausgefhrt werden, bevor der Kontrollfluss die try...catch...finally Konstruktion verlsst. Diese Anweisungen werden ausgefhrt, unabhngig davon, ob eine Ausnahme ausgelst oder gefangen wurde.

Beschreibung

Die try Anweisung beginnt immer mit einem try Block. Danach muss ein catch Block oder ein finally Block vorhanden sein. Es ist auch mglich, sowohl catch als auch finally Blcke zu haben. Dies gibt uns drei Formen fr die try Anweisung:

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

Im Gegensatz zu anderen Konstruktionen wie if oder for mssen die try, catch und finally Blcke Blcke sein, anstatt einzelner Anweisungen.

try doSomething(); // SyntaxError
catch (e) console.log(e);

Ein catch Block enthlt Anweisungen, die festlegen, was zu tun ist, wenn im try Block eine Ausnahme ausgelst wird. Wenn eine beliebige Anweisung im try Block (oder in einer aus dem try Block aufgerufenen Funktion) eine Ausnahme auslst, wird der Kontrollfluss sofort auf den catch Block verschoben. Wenn im try Block keine Ausnahme ausgelst wird, wird der catch Block bersprungen.

Der finally Block wird immer ausgefhrt, bevor der Kontrollfluss die try...catch...finally Konstruktion verlsst. Er wird immer ausgefhrt, unabhngig davon, ob eine Ausnahme ausgelst oder gefangen wurde.

Sie knnen eine oder mehrere try Anweisungen verschachteln. Wenn eine innere try Anweisung keinen catch Block hat, wird stattdessen der catch Block der umschlieenden try Anweisung verwendet.

Sie knnen die try Anweisung auch zur Behandlung von JavaScript-Ausnahmen verwenden. Siehe den JavaScript Leitfaden fr weitere Informationen zu JavaScript-Ausnahmen.

Catch Bindung

Wenn im try Block eine Ausnahme ausgelst wird, hlt exceptionVar (d.h. das e in catch (e)) den Ausnahme-Wert. Sie knnen diese Bindung verwenden, um Informationen ber die ausgelste Ausnahme zu erhalten. Diese Bindung ist nur im Scope des catch Blocks verfgbar.

Es muss kein einzelner Identifier sein. Sie knnen ein Destrukturierungs-Muster verwenden, um mehrere Identifier auf einmal zuzuweisen.

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

Die Bindungen, die durch die catch Klausel erstellt werden, existieren im selben Scope wie der catch Block, sodass jede im catch Block deklarierte Variable nicht denselben Namen wie die durch die catch Klausel erstellten Bindungen haben kann. (Es gibt eine Ausnahme von dieser Regel, aber es ist 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. Sie knnen beispielsweise den Ausnahmewert normalisieren, um sicherzustellen, dass es sich um ein Error 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 Ausnahmewert nicht bentigen, knnen Sie ihn zusammen mit den umgebenden Klammern weglassen.

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

Der finally Block

Der finally Block enthlt Anweisungen, die nach Ausfhrung des try Blocks und der catch Blcke, jedoch vor den Anweisungen nach dem try...catch...finally Block ausgefhrt werden. Der Kontrollfluss wird immer in den finally Block gelangen und kann auf eine der folgenden Arten fortsetzen:

• Unmittelbar nachdem der Kontrollfluss den try Block in einer try...finally Konstruktion verlsst (entweder nach der letzten Anweisung oder einer throw, return, break oder continue Anweisung);
• Unmittelbar nachdem der Kontrollfluss den catch Block in einer try...catch...finally Konstruktion verlsst;
• Unmittelbar nachdem der Kontrollfluss den try Block in einer try...catch...finally Konstruktion verlsst, es sei denn, er verlsst ihn ber eine throw Anweisung (in diesem Fall gelangt der Kontrollfluss zuerst in den catch Block).

Wenn der finally Block nach einer Kontrollflussanweisung (return, throw, break, continue) im try oder catch Block betreten wird, wird die Wirkung dieser Anweisung bis nach der letzten im finally Block ausgefhrten Anweisung aufgeschoben. Wenn beispielsweise eine Ausnahme aus dem try Block ausgelst wird, selbst wenn es keinen catch Block gibt, um die Ausnahme zu behandeln, wird der finally Block dennoch ausgefhrt, und die Ausnahme wird sofort nach Abschluss des finally Blocks ausgelst.

Es gibt jedoch eine Ausnahme von dieser Regel: Wenn die letzte Anweisung im finally Block selbst eine Kontrollflussanweisung ist, wird diese Anweisung die Wirkung der vorherigen aufheben (kein Aufschub); siehe Rckgabe aus einem finally Block fr Beispiele. Es ist im Allgemeinen eine schlechte Idee, Kontrollflussanweisungen (return, throw, break, continue) im finally Block zu verwenden, da sie die Wirkung von zuvor ausgefhrten Kontrollflussanweisungen berschreiben knnen, was selten beabsichtigt ist. Meistens sollte der finally Block fr Bereinigungscode reserviert werden, der die Hauptlogik nicht verndert.

Beispiele

Unbedingter catch Block

Wenn ein catch Block verwendet wird, wird der catch Block ausgefhrt, wenn eine Ausnahme aus dem try Block ausgelst wird. Zum Beispiel, wenn im folgenden Code die Ausnahme auftritt, wird der Kontrollfluss zum catch 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
}

Der catch Block gibt einen Bezeichner an (e im obigen Beispiel), der den Wert der Ausnahme hlt; dieser Wert ist nur im Scope des catch Blocks verfgbar.

Bedingte catch Blcke

Sie knnen "Bedingte catch Blcke" erstellen, indem Sie try...catch Blcke mit if...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
  }
}

Eine hufige Verwendung dafr ist, nur eine kleine Teilmenge erwarteter Fehler abzufangen (und zum Schweigen zu bringen) und dann im Falle anderer Fehler den Fehler erneut auszulsen:

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 anderer Sprachen, wie Java, nachahmen:

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

Verschachtelte try Blcke

Sehen wir zunchst, was 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 im inneren try Block bereits abgefangen haben, indem wir einen catch Block hinzugefgt haben:

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 nun, lassen Sie uns den Fehler erneut auslsen.

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 durch den nchstgelegenen umschlieenden catch Block abgefangen, es sei denn, sie wird erneut ausgelst. Natrlich werden alle neuen im "inneren" Block auftretenden Ausnahmen (weil der Code im catch Block etwas tun kann, das eine Ausnahme auslst) durch den "ueren" Block abgefangen.

Ressourcenbereinigung mit finally

Das folgende Beispiel zeigt einen Anwendungsfall fr den finally Block. Der Code ffnet eine Datei und fhrt dann Anweisungen aus, die die Datei verwenden; der finally Block stellt sicher, dass die Datei immer geschlossen wird, nachdem sie verwendet wurde, selbst wenn eine Ausnahme ausgelst wurde.

openMyFile();
try {
  // tie up a resource
  writeMyFile(theData);
} finally {
  closeMyFile(); // always close the resource
  // any uncaught exception is deferred here
}

Auf dieselbe Weise wird die Wirkung einer return Anweisung im try Block am Ende des finally Blocks aufgeschoben, obwohl der Return-Wert-Ausdruck ausgewertet wird, bevor der finally Block betreten wird.

function safeWriteMyFile() {
  openMyFile();
  try {
    return writeMyFile(theData); // function call is evaluated
  } finally {
    closeMyFile(); // always close the resource
    // return is deferred here
  }
}

Rckgabe aus einem finally Block

Das folgende Beispiel zeigt, wie Kontrollflussanweisungen im finally Block sich verhalten. Wenn der Kontrollfluss den try Block ber die erste return Anweisung verlsst, wird der Return-Wert Ausdruck (order.sort()) ausgewertet, bevor der finally Block betreten wird, und die Funktion ist geplant, diesen Wert nach Abschluss des finally Blocks zurckzugeben. Jedoch berschreibt die return Anweisung im finally Block die Wirkung der vorherigen return Anweisung, einschlielich deren Rckgabewert.

function doIt() {
  const order = ["z"];
  try {
    order.push("try");
    return order.sort(); // "z" is now after "try"
  } finally {
    order.push("finally");
    return order;
  }
}
doIt();
// returns ["try", "z", "finally"], not ["finally", "try", "z"] or ["try", "z"]

Die gleiche Logik gilt fr andere Kontrollflussanweisungen. Hier ist die Funktion zunchst geplant, den Wert "catch" auszulsen, gibt jedoch stattdessen den Wert "finally" zurck.

function doIt() {
  try {
    throw "try"; // makes control flow enter the `catch` block
  } catch {
    throw "catch"; // makes control flow enter the `finally` block
  } finally {
    return "finally"; // returns "finally" instead of throwing "catch"
  }
}
doIt(); // returns "finally"

Wieder einmal werden Kontrollflussanweisungen im finally Block entmutigt, da dieser Effekt wahrscheinlich nicht beabsichtigt ist.

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Error
• throw