Error

Laufzeitfehler führen zur Erstellung und Auslösung neuer Error-Objekte.

Error ist ein serialisierbares Objekt, daher kann es mit structuredClone() geklont oder zwischen Workers mit postMessage() kopiert werden.

Neben dem generischen Error-Konstruktor gibt es weitere Kernfehlerkonstruktoren in JavaScript. Für clientseitige Ausnahmen siehe Ausnahmebehandlungsanweisungen.

EvalError

Erstellt eine Instanz, die einen Fehler darstellt, der bei der Verwendung der globalen Funktion eval() auftritt.

RangeError

Erstellt eine Instanz, die einen Fehler darstellt, der auftritt, wenn eine numerische Variable oder ein Parameter außerhalb seines gültigen Bereichs ist.

ReferenceError

Erstellt eine Instanz, die einen Fehler darstellt, der beim Dereferenzieren eines ungültigen Verweises auftritt.

SyntaxError

Erstellt eine Instanz, die einen Syntaxfehler darstellt.

TypeError

Erstellt eine Instanz, die einen Fehler darstellt, der auftritt, wenn eine Variable oder ein Parameter nicht vom gültigen Typ ist.

URIError

Erstellt eine Instanz, die einen Fehler darstellt, der auftritt, wenn encodeURI() oder decodeURI() ungültige Parameter übergeben werden.

AggregateError

Erstellt eine Instanz, die mehrere Fehler umschließt, wenn mehrere Fehler in einer Operation gemeldet werden müssen, zum Beispiel bei Promise.any().

InternalError Nicht standardisiert

Erstellt eine Instanz, die einen Fehler darstellt, der auftritt, wenn ein interner Fehler in der JavaScript-Engine ausgelöst wird, z.B. "zu viel Rekursion".

Error()

Erstellt ein neues Error-Objekt.

Error.stackTraceLimit Nicht standardisiert

Eine nicht-standardmäßige numerische Eigenschaft, die begrenzt, wie viele Stack-Frames in einem Fehler-Stack-Tracing enthalten sind.

Error.captureStackTrace()

Eine nicht-standardmäßige Funktion, die die stack-Eigenschaft auf dem bereitgestellten Objekt erstellt.

Error.isError()

Gibt true zurück, wenn das Argument ein Fehler ist, oder false andernfalls.

Error.prepareStackTrace() Nicht standardisiert Optional

Eine nicht-standardmäßige Funktion, die, falls sie durch Benutzer-Code bereitgestellt wird, von der JavaScript-Engine für ausgelöste Ausnahmen aufgerufen wird, um benutzerdefiniertes Formatieren von Stack-Traces zu ermöglichen. Siehe die V8 Stack Trace API-Dokumentation.

Diese Eigenschaften sind auf Error.prototype definiert und werden von allen Error-Instanzen geteilt.

Error.prototype.constructor

Die Konstruktionsfunktion, die das Instanzobjekt erstellt hat. Für Error-Instanzen ist der Anfangswert der Error-Konstruktor.

Error.prototype.name

Repräsentiert den Namen des Fehler-Typs. Für Error.prototype.name ist der Anfangswert "Error". Unterklassen wie TypeError und SyntaxError stellen ihre eigenen name-Eigenschaften bereit.

Error.prototype.stack Nicht standardisiert

Eine nicht-standardmäßige Eigenschaft für eine Stack-Tracing.

Diese Eigenschaften sind eigene Eigenschaften jeder Error-Instanz.

cause

Fehlerursache, die den Grund angibt, warum der aktuelle Fehler ausgelöst wird — üblicherweise ein anderer abgefangener Fehler. Für benutzererstellte Error-Objekte ist dies der Wert, der als cause-Eigenschaft des zweiten Arguments des Konstruktors bereitgestellt wird.

columnNumber Nicht standardisiert

Eine nicht-standardmäßige Mozilla-Eigenschaft für die Spaltennummer in der Zeile, die diesen Fehler verursacht hat.

fileName Nicht standardisiert

Eine nicht-standardmäßige Mozilla-Eigenschaft für den Pfad zur Datei, die diesen Fehler verursacht hat.

lineNumber Nicht standardisiert

Eine nicht-standardmäßige Mozilla-Eigenschaft für die Zeilennummer in der Datei, die diesen Fehler verursacht hat.

message

Fehlermeldung. Für benutzererstellte Error-Objekte ist dies der als erstes Argument des Konstruktors bereitgestellte String.

Error.prototype.toString()

Gibt einen String zurück, der das angegebene Objekt darstellt. Überschreibt die Object.prototype.toString()-Methode.

Normalerweise erstellt man ein Error-Objekt mit der Absicht, es mittels des Schlüsselwortes throw auszulösen. Sie können den Fehler mit der Konstruktion try...catch behandeln:

try {
  throw new Error("Whoops!");
} catch (e) {
  console.error(`${e.name}: ${e.message}`);
}

Sie können sich entscheiden, nur bestimmte Fehlertypen zu behandeln, indem Sie den Fehlertyp mit dem Schlüsselwort instanceof testen:

try {
  foo.bar();
} catch (e) {
  if (e instanceof EvalError) {
    console.error(`${e.name}: ${e.message}`);
  } else if (e instanceof RangeError) {
    console.error(`${e.name}: ${e.message}`);
  }
  // etc.
  else {
    // If none of our cases matched leave the Error unhandled
    throw e;
  }
}

Manchmal kann ein Codeblock aus Gründen fehlschlagen, die eine unterschiedliche Behandlung erfordern, aber sehr ähnliche Fehler auslösen (d.h. mit demselben Typ und derselben Nachricht).

Wenn Sie keine Kontrolle über die ursprünglich ausgelösten Fehler haben, ist eine Option, diese abzufangen und neue Error-Objekte mit spezifischeren Nachrichten auszulösen. Der ursprüngliche Fehler sollte an das neue Error-Objekt im options-Parameter des Konstruktors als seine cause-Eigenschaft übergeben werden. Dies stellt sicher, dass der ursprüngliche Fehler und Stack-Trace für höherstufige try/catch-Blöcke verfügbar sind.

Das folgende Beispiel zeigt dies für zwei Methoden, die ansonsten mit ähnlichen Fehlern fehlschlagen würden (doFailSomeWay() und doFailAnotherWay()):

function doWork() {
  try {
    doFailSomeWay();
  } catch (err) {
    throw new Error("Failed in some way", { cause: err });
  }
  try {
    doFailAnotherWay();
  } catch (err) {
    throw new Error("Failed in another way", { cause: err });
  }
}

try {
  doWork();
} catch (err) {
  switch (err.message) {
    case "Failed in some way":
      handleFailSomeWay(err.cause);
      break;
    case "Failed in another way":
      handleFailAnotherWay(err.cause);
      break;
  }
}

Benutzerdefinierte Fehlertypen können ebenfalls die cause-Eigenschaft verwenden, sofern der Konstruktor der Unterklassen den Parameter options beim Aufruf von super() weitergibt. Der Error()-Basisklassenkonstruktor wird options.cause lesen und die cause-Eigenschaft auf der neuen Fehlerinstanz definieren.

class MyError extends Error {
  constructor(message, options) {
    // Need to pass `options` as the second parameter to install the "cause" property.
    super(message, options);
  }
}

console.log(new MyError("test", { cause: new Error("cause") }).cause);
// Error: cause

Möglicherweise möchten Sie Ihre eigenen Fehlertypen definieren, die von Error abgeleitet sind, um throw new MyError() verwenden zu können und mit instanceof MyError die Art des Fehlers im Ausnahmehandler zu überprüfen. Dies führt zu saubererem und einheitlicherem Fehlerbehandlungscode.

Siehe "What's a good way to extend Error in JavaScript?" auf Stack Overflow für eine ausführliche Diskussion.

class CustomError extends Error {
  constructor(foo = "bar", ...params) {
    // Pass remaining arguments (including vendor specific ones) to parent constructor
    super(...params);

    // Maintains proper stack trace for where our error was thrown (non-standard)
    if (Error.captureStackTrace) {
      Error.captureStackTrace(this, CustomError);
    }

    this.name = "CustomError";
    // Custom debugging information
    this.foo = foo;
    this.date = new Date();
  }
}

try {
  throw new CustomError("baz", "bazMessage");
} catch (e) {
  console.error(e.name); // CustomError
  console.error(e.foo); // baz
  console.error(e.message); // bazMessage
  console.error(e.stack); // stack trace
}

• Polyfill von Error mit cause-Unterstützung in core-js
• es-shims Polyfill von Error cause
• throw
• try...catch
• Stack Trace API in den V8-Dokumenten