new SuppressedError() — Methode · JavaScript-Referenz

Signatur

new SuppressedError(error, suppressed, message)

Beschreibung

Der Konstruktor SuppressedError() erzeugt einen Fehler, der zwei Fehler zusammenfasst: den Fehler, der zuletzt aufgetreten ist (error), und einen früheren Fehler, der dadurch verdrängt wurde (suppressed). So geht bei der Fehlerbehandlung keine Information verloren.

Gedacht ist der Typ vor allem für die explizite Ressourcenverwaltung mit using, await using, DisposableStack und AsyncDisposableStack. Wirft ein Codeblock einen Fehler und schlägt danach auch das Aufräumen ([Symbol.dispose]()) fehl, erzeugt die Laufzeitumgebung automatisch einen SuppressedError: In error steht der Fehler beim Aufräumen, in suppressed der ursprüngliche Fehler aus dem Block.

Du kannst den Konstruktor auch selbst aufrufen, zum Beispiel in eigenen Aufräumroutinen mit try…finally, wenn im finally-Block ein zweiter Fehler auftritt. Der Aufruf funktioniert mit und ohne new. Das Ergebnis ist eine Instanz von SuppressedError und Error, der name ist "SuppressedError".

Parameter

Name	Typ	Default	Beschreibung
$error Pflicht	any		Der zuletzt aufgetretene Fehler, der den früheren verdrängt. Er wird in der Eigenschaft `error` gespeichert. Jeder Wert ist erlaubt, nicht nur `Error`-Objekte.
$suppressed Pflicht	any		Der frühere Fehler, der verdrängt wurde. Er wird in der Eigenschaft `suppressed` gespeichert.
$message	string	"" (geerbt von Error.prototype.message)	Optionale, lesbare Fehlermeldung. Werte, die keine Zeichenketten sind, werden in Zeichenketten umgewandelt. Fehlt der Parameter, wird keine eigene `message`-Eigenschaft angelegt.

Rückgabewert

Typ

SuppressedError

Beschreibung

Ein neues SuppressedError-Objekt mit den eigenen Eigenschaften error, suppressed und, falls angegeben, message.

Beispiele

SuppressedError direkt erzeugen

const cleanupError = new Error('Datei konnte nicht geschlossen werden');
const originalError = new TypeError('Ungültiges Format');

const err = new SuppressedError(cleanupError, originalError, 'Fehler beim Verarbeiten');

console.log(err instanceof SuppressedError); // true
console.log(err instanceof Error);           // true
console.log(err.name);                       // SuppressedError
console.log(err.message);
console.log(err.error.message);
console.log(err.suppressed.message);

true true SuppressedError Fehler beim Verarbeiten Datei konnte nicht geschlossen werden Ungültiges Format

Automatisch erzeugt durch DisposableStack

const stack = new DisposableStack();
stack.defer(() => {
  throw new Error('Aufräumen fehlgeschlagen');
});

try {
  try {
    throw new Error('Verarbeitung fehlgeschlagen');
  } finally {
    stack.dispose();
  }
} catch (e) {
  // dispose() wirft hier nur den Aufräumfehler; die Kombination
  // entsteht bei using bzw. bei mehreren fehlschlagenden Callbacks
  console.log(e.message);
}

// Mehrere fehlschlagende Aufräum-Callbacks:
const stack2 = new DisposableStack();
stack2.defer(() => { throw new Error('A'); });
stack2.defer(() => { throw new Error('B'); });

try {
  stack2.dispose(); // Reihenfolge LIFO: erst B, dann A
} catch (e) {
  console.log(e.name, e.error.message, e.suppressed.message);
}

Aufräumen fehlgeschlagen SuppressedError A B

Eigene Aufräumlogik mit try…finally

const withConnection = async (task) => {
  const conn = { close: async () => { throw new Error('Verbindung hängt'); } };
  let taskError;
  try {
    return await task(conn);
  } catch (e) {
    taskError = e;
    throw e;
  } finally {
    try {
      await conn.close();
    } catch (closeError) {
      // Keinen Fehler verlieren: beide zusammen weiterreichen
      if (taskError !== undefined) {
        throw new SuppressedError(closeError, taskError, 'Task und Cleanup fehlgeschlagen');
      }
      throw closeError;
    }
  }
};

try {
  await withConnection(async () => { throw new Error('Query fehlgeschlagen'); });
} catch (e) {
  console.log(e.message);
  console.log('Cleanup:', e.error.message);
  console.log('Ursprung:', e.suppressed.message);
}

Task und Cleanup fehlgeschlagen Cleanup: Verbindung hängt Ursprung: Query fehlgeschlagen

// Wichtig · Fallstricke

Reihenfolge der Argumente beachten: Das erste Argument (error) ist der neuere Fehler, das zweite (suppressed) der ältere, verdrängte. Wer das vertauscht, zeigt in Logs die falsche Ursache.
Anders als Error() hat der Konstruktor keinen options-Parameter, also kein { cause }. Die Verknüpfung läuft über error und suppressed.
Bei mehreren fehlschlagenden Aufräum-Schritten entstehen verschachtelte SuppressedError-Objekte. Zum vollständigen Loggen musst du rekursiv über suppressed gehen.
Kompatibilität: Der Typ gehört zum Vorschlag „Explicit Resource Management“ und ist neu. In älteren Browsern und in Safari fehlt SuppressedError. Prüfe vor der Nutzung mit typeof SuppressedError !== 'undefined' oder setze ein Polyfill ein (z. B. core-js). TypeScript unterstützt den Typ ab 5.2 mit lib: ["esnext.disposable"].

Siehe auch

SuppressedError SuppressedError.prototype.error SuppressedError.prototype.suppressed AggregateError Error DisposableStack AsyncDisposableStack using Symbol.dispose