Baseline Widely available
Die try...catch-Anweisung besteht aus einem try-Block und entweder einem catch-Block, einem finally-Block oder beiden. Der Code im try-Block wird zuerst ausgeführt, und wenn er eine Ausnahme wirft, wird der Code im catch-Block ausgeführt. Der Code im finally-Block wird immer ausgeführt, bevor der Kontrollfluss die gesamte Konstruktion verlässt.
try {
nonExistentFunction();
} catch (error) {
console.error(error);
// Expected output: ReferenceError: nonExistentFunction is not defined
// (Note: the exact output may be browser-dependent)
}
try {
tryStatements
} catch (exceptionVar) {
catchStatements
} finally {
finallyStatements
}
tryStatements
Die Anweisungen, die ausgeführt werden sollen.
catchStatements
Anweisung, die ausgeführt wird, wenn im try-Block eine Ausnahme ausgelöst wird.
exceptionVar Optional
Ein optionaler Identifier oder ein Muster, um die gefangene Ausnahme für den zugehörigen catch-Block zu halten. Wenn der catch-Block den Wert der Ausnahme nicht verwendet, können Sie exceptionVar und seine umgebenden Klammern weglassen.
finallyStatements
Anweisungen, die ausgeführt werden, bevor der Kontrollfluss die try...catch...finally-Konstruktion verlässt. Diese Anweisungen werden ausgeführt, unabhängig davon, ob eine Ausnahme ausgelöst oder gefangen wurde.
Die try-Anweisung beginnt immer mit einem try-Block. Dann muss ein catch-Block oder ein finally-Block vorhanden sein. Es ist auch möglich, sowohl catch- als auch finally-Blöcke zu haben. Dies gibt uns drei Formen für die try-Anweisung:
try...catchtry...finallytry...catch...finallyIm Gegensatz zu anderen Konstruktionen wie if oder for müssen die try, catch und finally-Blöcke Blöcke und keine einzelnen Anweisungen sein.
try doSomething(); // SyntaxError
catch (e) console.log(e);
Ein catch-Block enthält Anweisungen, die angeben, was zu tun ist, wenn im try-Block eine Ausnahme ausgelöst wird. Wenn eine Anweisung im try-Block (oder in einer Funktion, die aus dem try-Block aufgerufen wird) eine Ausnahme auslöst, wird der Kontrollfluss sofort auf den catch-Block verlagert. Wenn im try-Block keine Ausnahme ausgelöst wird, wird der catch-Block übersprungen.
Der finally-Block wird immer ausgeführt, bevor der Kontrollfluss die try...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 mehrere try-Anweisungen verschachteln. Wenn eine innere try-Anweisung keinen catch-Block hat, wird der catch-Block der umschlieÃenden try-Anweisung stattdessen verwendet.
Sie können die try-Anweisung auch verwenden, um JavaScript-Ausnahmen zu behandeln. Weitere Informationen zu JavaScript-Ausnahmen finden Sie im JavaScript-Leitfaden.
Wenn im try-Block eine Ausnahme ausgelöst wird, hält exceptionVar (d.h. das e in catch (e)) den Ausnahme-Wert. Sie können diese Bindung verwenden, um Informationen über die ausgelöste Ausnahme zu erhalten. Diese Bindung ist nur im Gültigkeitsbereich des catch-Blocks verfügbar.
Es muss kein einzelner Bezeichner sein. Sie können ein Destrukturierungsmuster verwenden, um mehrere Bezeichner gleichzeitig zuzuweisen.
try {
throw new TypeError("oops");
} catch ({ name, message }) {
console.log(name); // "TypeError"
console.log(message); // "oops"
}
Die durch die catch-Klausel erstellten Bindungen existieren im selben Gültigkeitsbereich wie der catch-Block, daher können im catch-Block deklarierte Variablen nicht denselben Namen wie die durch die catch-Klausel erstellten Bindungen haben. (Es gibt eine 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 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 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;
}
}
Der finally-Block enthält Anweisungen, die nach der Ausführung des try-Blocks und catch-Blocks ausgeführt werden, jedoch vor den Anweisungen, die dem try...catch...finally-Block folgen. Der Kontrollfluss wird den finally-Block immer betreten, was auf eine der folgenden Weisen geschehen kann:
try-Block die Ausführung normal beendet hat (und keine Ausnahmen wurden ausgelöst);catch-Block die Ausführung normal beendet hat;return, throw, break, continue) im try-Block oder catch-Block erfolgt, die den Block verlassen würde.Wenn eine Ausnahme aus dem try-Block ausgelöst wird, selbst wenn kein catch-Block vorhanden ist, um die Ausnahme zu behandeln, wird der finally-Block trotzdem ausgeführt, wobei die Ausnahme sofort nach dem Abschluss des finally-Blocks erneut ausgelöst wird.
Das folgende Beispiel zeigt einen Anwendungsfall für den finally-Block. Der Code öffnet eine Datei und führt 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 ausgelöst wurde.
openMyFile();
try {
// tie up a resource
writeMyFile(theData);
} finally {
closeMyFile(); // always close the resource
}
Kontrollflussanweisungen (return, throw, break, continue) im finally-Block werden jeden Abschlusswert des try-Blocks oder catch-Blocks "maskieren". In diesem Beispiel versucht der try-Block, 1 zurückzugeben, aber bevor die Rückgabe erfolgt, wird der Kontrollfluss zuerst dem finally-Block zugeführt, sodass der Rückgabewert des finally-Blocks stattdessen zurückgegeben wird.
function doIt() {
try {
return 1;
} finally {
return 2;
}
}
doIt(); // returns 2
Es ist generell eine schlechte Idee, Kontrollflussanweisungen im finally-Block zu verwenden. Verwenden Sie ihn nur für Bereinigungscode.
Wenn ein catch-Block verwendet wird, wird der catch-Block ausgeführt, wenn eine Ausnahme von innerhalb des try-Blocks ausgelöst wird. Beispielsweise, wenn die Ausnahme im folgenden Code auftritt, wird der Kontrollfluss auf den 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 hält; dieser Wert ist nur im Gültigkeitsbereich des catch-Blocks verfügbar.
Sie können "Bedingte catch-Blöcke" erstellen, indem Sie try...catch-Blöcke 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
}
}
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 inneren try-Block gefangen haben, indem wir einen catch-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Ãenden catch-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 im catch-Block etwas tun kann, das ein Auslösen verursacht), vom "äuÃeren" Block gefangen.
Wenn der finally-Block einen Wert zurückgibt, wird dieser Wert zum Rückgabewert der gesamten try-catch-finally-Anweisung, unabhängig von allen return-Anweisungen in den try und catch-Blöcken. Dies schlieÃt Ausnahmen ein, die innerhalb des catch-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 im finally-Block erfolgt. Dasselbe gilt für jeden Wert, der vom catch-Block zurückgegeben wird.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4