DasSuppressedError-Objekt repräsentiert einen Fehler, der während der Behandlung eines anderen Fehlers erzeugt wurde. Es wird bei der Freigabe von Ressourcen mittelsusing oderawait using erzeugt.

Im Vergleich zuAggregateError wirdSuppressedError verwendet, um einen einzelnen Fehler darzustellen, der durch einen anderen Fehler unterdrückt wird, währendAggregateError eine Liste von nicht zusammenhängenden Fehlern darstellt. Es ist jedoch möglich, dass einSuppressedError eine Kette von unterdrückten Fehlern enthält (e.suppressed.suppressed.suppressed...). Es unterscheidet sich auch semantisch voncause, da der Fehler nichtdurch einen anderen Fehler verursacht wird, sondernauftritt, wenn ein anderer Fehler gehandhabt wird.

SuppressedError ist eine Unterklasse vonError.

Konstruktor

SuppressedError()

Erstellt ein neuesSuppressedError-Objekt.

Instanz-Eigenschaften

Erbt auch Instanz-Eigenschaften von seinem ElternteilError.

Diese Eigenschaften sind aufSuppressedError.prototype definiert und werden von allenSuppressedError-Instanzen geteilt.

SuppressedError.prototype.constructor

Die Konstruktorfunktion, die das Instanzobjekt erstellt hat. FürSuppressedError-Instanzen ist der anfängliche Wert derSuppressedError-Konstruktor.

SuppressedError.prototype.name

Repräsentiert den Namen für den Fehlertyp. FürSuppressedError.prototype.name ist der Anfangswert"SuppressedError".

Diese Eigenschaften sind eigene Eigenschaften jederSuppressedError-Instanz.

error

Ein Verweis auf den Fehler, der zur Unterdrückung führt.

suppressed

Ein Verweis auf den Fehler, der durcherror unterdrückt wird.

Instanz-Methoden

Erbt Instanz-Methoden von seinem ElternteilError.

Beispiele

Abfangen eines SuppressedError

EinSuppressedError wird ausgelöst, wenn während derRessourcenfreigabe ein Fehler auftritt. Das Auslösen eines Fehlers bewirkt die Bereinigung des Geltungsbereichs, und jeder Disposer während der Bereinigung kann seinen eigenen Fehler auslösen. All diese Fehler werden in eine Kette vonSuppressedError-Instanzen gesammelt, wobei der ursprüngliche Fehler alssuppressed-Eigenschaft und der neue Fehler, der vom nächsten Disposer ausgelöst wird, alserror-Eigenschaft fungiert.

try {  using resource1 = {    [Symbol.dispose]() {      throw new Error("Error while disposing resource1");    },  };  using resource2 = {    [Symbol.dispose]() {      throw new Error("Error while disposing resource2");    },  };  throw new Error("Original error");} catch (e) {  console.log(e instanceof SuppressedError); // true  console.log(e.message); // "An error was suppressed during disposal"  console.log(e.name); // "SuppressedError"  console.log(e.error); // Error: Error while disposing resource1  console.log(e.suppressed); // SuppressedError: An error was suppressed during disposal  console.log(e.suppressed.error); // Error: Error while disposing resource2  console.log(e.suppressed.suppressed); // Error: Original error}

Die Kette sieht so aus:

       SuppressedError --suppressed--> SuppressedError --suppressed--> Original error              |                               |            error                           error              v                               vError while disposing resource1   Error while disposing resource2    (Disposal happens later)        (Disposal happens earlier)

Erstellen eines SuppressedError

try {  throw new SuppressedError(    new Error("New error"),    new Error("Original error"),    "Hello",  );} catch (e) {  console.log(e instanceof SuppressedError); // true  console.log(e.message); // "Hello"  console.log(e.name); // "SuppressedError"  console.log(e.error); // Error: "New error"  console.log(e.suppressed); // Error: "Original error"}

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Polyfill vonSuppressedError incore-js
• Error
• using
• await using
• DisposableStack
• AsyncDisposableStack