Error

Laufzeitfehler führen dazu, dass neue Error-Objekte erstellt und geworfen werden.

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 andere Kern-Fehlerkonstruktoren in JavaScript. Für clientseitige Ausnahmen siehe Ausnahmebehandlungsanweisungen.

EvalError

Erstellt eine Instanz, die einen Fehler darstellt, der im Zusammenhang mit der globalen Funktion eval() auftritt.

RangeError

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

ReferenceError

Erstellt eine Instanz, die einen Fehler darstellt, der auftritt, wenn auf eine ungültige Referenz verwiesen wird.

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 den richtigen Typ hat.

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 in einem einzigen Fehler umschließt, wenn bei einem Vorgang mehrere Fehler gemeldet werden müssen, zum Beispiel durch Promise.any().

InternalError Nicht standardisiert

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

Error()

Erstellt ein neues Error-Objekt.

Error.captureStackTrace() Nicht standardisiert

Eine nicht standardmäßige V8-Funktion, die die Eigenschaft stack auf einer Fehlerinstanz erstellt.

Error.stackTraceLimit Nicht standardisiert

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

Error.prepareStackTrace() Nicht standardisiert Optional

Eine nicht standardmäßige V8-Funktion, die, wenn sie vom Benutzer bereitgestellt wird, von der V8-JavaScript-Engine für geworfene Ausnahmen aufgerufen wird und es dem Benutzer ermöglicht, benutzerdefinierte Formatierungen für Stacktraces bereitzustellen.

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

Error.prototype.constructor

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

Error.prototype.name

Repräsentiert den Namen für den Fehlertyp. Für Error.prototype.name ist der Anfangswert "Error". Unterklassen wie TypeError und SyntaxError bieten ihre eigenen name-Eigenschaften.

Error.prototype.stack Nicht standardisiert

Eine nicht standardmäßige Eigenschaft für einen Stacktrace.

Diese Eigenschaften sind eigene Eigenschaften jeder Error-Instanz.

cause

Fehlerursache, die den Grund angibt, warum der aktuelle Fehler geworfen wird — normalerweise ein anderer abgefangener Fehler. Bei vom Benutzer erstellten Error-Objekten ist dies der Wert, der als cause-Eigenschaft des zweiten Arguments des Konstruktors angegeben wird.

columnNumber Nicht standardisiert

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

fileName Nicht standardisiert

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

lineNumber Nicht standardisiert

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

message

Fehlermeldung. Bei vom Benutzer erstellten Error-Objekten ist dies der als erstes Argument des Konstruktors angegebene String.

Error.prototype.toString()

Gibt einen String zurück, der das spezifizierte Objekt repräsentiert. Überschreibt die Methode Object.prototype.toString().

Normalerweise erstellen Sie ein Error-Objekt mit der Absicht, es mit dem Schlüsselwort throw zu werfen. Sie können den Fehler mit dem Konstrukt 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 Handhabung erfordern, aber sehr ähnliche Fehler werfen (d. h. mit demselben Typ und derselben Nachricht).

Wenn Sie keine Kontrolle über die ursprünglich geworfenen Fehler haben, besteht eine Möglichkeit darin, sie abzufangen und neue Error-Objekte mit spezifischeren Nachrichten zu werfen. Der ursprüngliche Fehler sollte an den neuen Error im options-Parameter des Konstruktors als seine cause-Eigenschaft übergeben werden. Dies stellt sicher, dass der ursprüngliche Fehler und Stacktrace für höherstufige try/catch-Blöcke verfügbar sind.

Das folgende Beispiel zeigt dies für zwei Methoden, die sonst 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 options-Parameter beim Aufrufen von super() übergibt. Der Error()-Basisklassenkonstruktor wird options.cause lesen und die cause-Eigenschaft in 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

Es könnte für Sie sinnvoll sein, eigene Fehlertypen von Error abzuleiten, 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 konsistenterem Fehlerbehandlungscode.

Sehen Sie sich "What’s a good way to extend Error in JavaScript?" auf Stack Overflow für eine ausführliche Diskussion an.

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 (only available on V8)
    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); // stacktrace
}

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