DasSuppressedError Objekt repräsentiert einen Fehler, der beim Handhaben eines anderen Fehlers entsteht. Es wird während der Ressourcenfreigabe mitusing oderawait using erzeugt.

Im Vergleich zuAggregateError stehtSuppressedError für einen Fehler, der beim Umgang mit einem anderen Fehler auftritt, 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 nicht durch einen anderen Fehlerverursacht 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 Anfangswert derSuppressedError Konstruktor.

SuppressedError.prototype.name

Repräsentiert den Namen des Fehlertyps. FürSuppressedError.prototype.name ist der Anfangswert"SuppressedError".

Diese Eigenschaften sind eigene Eigenschaften jederSuppressedError Instanz.

error

Eine Referenz auf den Fehler, der zur Unterdrückung führt.

suppressed

Eine Referenz auf den Fehler, der durcherror unterdrückt wird.

Instanz-Methoden

Erbt Instanz-Methoden von seinem ElternteilError.

Beispiele

Auffangen eines SuppressedError

EinSuppressedError wird ausgelöst, wenn ein Fehler während derRessourcenfreigabe auftritt. Das Auslösen eines Fehlers verursacht eine Bereichsbereinigung, und jeder Putzer während der Bereinigung kann seinen eigenen Fehler werfen. 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 Putzer geworfen wird, alserror Eigenschaft dargestellt wird.

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