Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten.Erfahre mehr über dieses Experiment.
Promise.prototype.catch()
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since Juli 2015.
Diecatch() Methode vonPromise Instanzen plant eine Funktion ein, die aufgerufen wird, wenn dasPromise abgelehnt wird. Sie gibt sofort ein anderesPromise-Objekt zurück, das es Ihnen ermöglicht, Aufrufe andererPromise-Methoden zuverkettet zu behandeln. Sie ist eine Abkürzung fürthen(undefined, onRejected).
Probieren Sie es aus
const promise = new Promise((resolve, reject) => { throw new Error("Uh-oh!");});promise.catch((error) => { console.error(error);});// Expected output: Error: Uh-oh!Syntax
promiseInstance.catch(onRejected)Parameter
onRejectedEine Funktion, die asynchron ausgeführt wird, wenn dieses
Promiseabgelehnt wird. Ihr Rückgabewert wird zum Erfüllungswert des voncatch()zurückgegebenenPromise. Die Funktion wird mit den folgenden Argumenten aufgerufen:reasonDer Wert, mit dem das
Promiseabgelehnt wurde.
Rückgabewert
Gibt ein neuesPromise zurück. Dieses neuePromise ist immer ausstehend, wenn es zurückgegeben wird, unabhängig vom Status des aktuellenPromise. WennonRejected aufgerufen wird, wird das zurückgegebenePromise basierend auf dem Rückgabewert dieses Aufrufs erfüllt oder mit dem ausgeworfenen Fehler aus diesem Aufruf abgelehnt. Wenn das aktuellePromise erfüllt wird, wirdonRejected nicht aufgerufen, und das zurückgegebenePromise wird mit demselben Wert erfüllt.
Beschreibung
Diecatch-Methode wird zur Fehlerbehandlung in Promise-Kompositionen verwendet. Da sie einPromise zurückgibt,kann sie verkettet werden, ähnlich wie ihre Schwestermethode,then().
Wenn einPromise abgelehnt wird und es keine Ablehnungsverarbeitungsroutinen gibt, die aufgerufen werden können (eine Verarbeitungsroutine kann durch eines derthen(),catch(), oderfinally()-Methode angefügt werden), wird das Ablehnungsereignis vom Host bereitgestellt. Im Browser führt dies zu einemunhandledrejection Ereignis. Wenn an ein abgelehntesPromise, dessen Ablehnung bereits ein unbehandeltes Ablehnungsereignis verursacht hat, eine Verarbeitungsroutine angefügt wird, wird ein weiteresrejectionhandled Ereignis ausgelöst.
catch() ruft internthen() auf dem Objekt auf, auf dem es aufgerufen wurde, und übergibtundefined undonRejected als Argumente. Der Rückgabewert dieses Aufrufs wird direkt zurückgegeben. Dies ist beobachtbar, wenn Sie die Methoden umschließen.
// overriding original Promise.prototype.then/catch just to add some logs((Promise) => { const originalThen = Promise.prototype.then; const originalCatch = Promise.prototype.catch; Promise.prototype.then = function (...args) { console.log("Called .then on %o with arguments: %o", this, args); return originalThen.apply(this, args); }; Promise.prototype.catch = function (...args) { console.error("Called .catch on %o with arguments: %o", this, args); return originalCatch.apply(this, args); };})(Promise);// calling catch on an already resolved promisePromise.resolve().catch(function XXX() {});// Logs:// Called .catch on Promise{} with arguments: Arguments{1} [0: function XXX()]// Called .then on Promise{} with arguments: Arguments{2} [0: undefined, 1: function XXX()]Das bedeutet, dass die Übergabe vonundefined weiterhin dazu führt, dass das zurückgegebenePromise abgelehnt wird, und Sie müssen eine Funktion übergeben, um zu verhindern, dass das endgültigePromise abgelehnt wird.
Weilcatch() einfachthen() aufruft, unterstützt es Subklassifizierung.
Hinweis:Die untenstehenden Beispiele werfen Instanzen vonError. Wie bei synchronenthrow Anweisungen wird dies als gute Praxis angesehen; andernfalls müsste der Teil, der das Abfangen übernimmt, Überprüfungen durchführen, um festzustellen, ob das Argument ein String oder ein Fehler war, und Sie könnten wertvolle Informationen wie Stack-Traces verlieren.
Beispiele
Verwendung und Verkettung der catch()-Methode
const p1 = new Promise((resolve, reject) => { resolve("Success");});p1.then((value) => { console.log(value); // "Success!" throw new Error("oh, no!");}) .catch((e) => { console.error(e.message); // "oh, no!" }) .then( () => console.log("after a catch the chain is restored"), // "after a catch the chain is restored" () => console.log("Not fired due to the catch"), );// The following behaves the same as abovep1.then((value) => { console.log(value); // "Success!" return Promise.reject(new Error("oh, no!"));}) .catch((e) => { console.error(e); // Error: oh, no! }) .then( () => console.log("after a catch the chain is restored"), // "after a catch the chain is restored" () => console.log("Not fired due to the catch"), );Fallstricke beim Werfen von Fehlern
Das Werfen eines Fehlers wird meist diecatch() Methode aufrufen:
const p1 = new Promise((resolve, reject) => { throw new Error("Uh-oh!");});p1.catch((e) => { console.error(e); // "Uh-oh!"});Fehler, die innerhalb von asynchronen Funktionen geworfen werden, verhalten sich wie nicht abgefangene Fehler:
const p2 = new Promise((resolve, reject) => { setTimeout(() => { throw new Error("Uncaught Exception!"); }, 1000);});p2.catch((e) => { console.error(e); // This is never called});Fehler, die nach dem Aufruf vonresolve geworfen werden, werden unterdrückt:
const p3 = new Promise((resolve, reject) => { resolve(); throw new Error("Silenced Exception!");});p3.catch((e) => { console.error(e); // This is never called});catch() wird nicht aufgerufen, wenn dasPromise erfüllt wird
// Create a promise which would not call onRejectconst p1 = Promise.resolve("calling next");const p2 = p1.catch((reason) => { // This is never called console.error("catch p1!"); console.error(reason);});p2.then( (value) => { console.log("next promise's onFulfilled"); console.log(value); // calling next }, (reason) => { console.log("next promise's onRejected"); console.log(reason); },);Spezifikationen
| Specification |
|---|
| ECMAScript® 2026 Language Specification # sec-promise.prototype.catch |