Error

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

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

Neben dem generischen Error-Konstruktor gibt es weitere grundlegende Fehlerkonstruktoren in JavaScript. Für clientseitige Ausnahmen siehe Ausdruckshandhabungsanweisungen.

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 des gültigen Bereichs liegt.

ReferenceError

Erstellt eine Instanz, die einen Fehler darstellt, der auftritt, wenn eine ungültige Referenz dereferenziert 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 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 in einem einzigen Fehler eingeschlossen darstellt, wenn eine Operation mehrere Fehler melden muss, z.B. 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. "zuviel Rekursion".

Error()

Erstellt ein neues Error-Objekt.

Error.stackTraceLimit Nicht standardisiert

Eine nicht standardisierte numerische Eigenschaft, die festlegt, wie viele Stapelrahmen in einer Fehlerstackverfolgung enthalten sein sollen.

Error.captureStackTrace() Nicht standardisiert

Eine nicht standardisierte Funktion, die die stack-Eigenschaft für das bereitgestellte Objekt erstellt.

Error.isError()

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

Error.prepareStackTrace() Nicht standardisiert Optional

Eine nicht standardisierte Funktion, die, falls vom Benutzer bereitgestellt, von der JavaScript-Engine für geworfene Ausnahmen aufgerufen wird und es dem Benutzer ermöglicht, eine benutzerdefinierte Formatierung für Stackverfolgungen bereitzustellen. Siehe die V8 Stack Trace API-Dokumentation.

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

Error.prototype.constructor

Die Konstrukturfunktion, 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 stellen ihre eigenen name-Eigenschaften bereit.

Error.prototype.stack Nicht standardisiert

Eine nicht standardisierte Eigenschaft für eine Stapelverfolgung.

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 benutzererstellten Error-Objekten ist dies der Wert, der als cause-Eigenschaft des zweiten Arguments des Konstruktors bereitgestellt wird.

columnNumber Nicht standardisiert

Eine nicht standardisierte Mozilla-Eigenschaft für die Spaltennummer in der Zeile, die diesen Fehler verursacht hat.

fileName Nicht standardisiert

Eine nicht standardisierte Mozilla-Eigenschaft für den Pfad zur Datei, die diesen Fehler verursacht hat.

lineNumber Nicht standardisiert

Eine nicht standardisierte Mozilla-Eigenschaft für die Zeilennummer in der Datei, die diesen Fehler verursacht hat.

message

Fehlermeldung. Bei benutzererstellten Error-Objekten ist dies der Zeichenfolgenwert, der als erstes Argument des Konstruktors bereitgestellt wird.

Error.prototype.toString()

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

In der Regel erstellen Sie ein Error-Objekt mit der Absicht, es mit dem throw-Schlüsselwort zu werfen. Sie können den Fehler mit der try...catch-Konstruktion behandeln:

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

Sie können wählen, nur bestimmte Fehlertypen zu behandeln, indem Sie den Fehlertyp mit dem instanceof-Operator 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, ist eine Option, sie abzufangen und neue Error-Objekte zu werfen, die spezifischere Nachrichten haben. Der ursprüngliche Fehler sollte dem neuen Error im options-Parameter des Konstruktors als cause-Eigenschaft übergeben werden. Dies stellt sicher, dass der ursprüngliche Fehler und die Stackverfolgung 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 auch die cause-Eigenschaft verwenden, vorausgesetzt, der Konstruktor der Unterklassen übergibt den options-Parameter beim Aufruf von super(). Der Error()-Basisklassen-Konstruktor 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

Es kann sinnvoll sein, eigene Fehlertypen abzuleiten, die von Error erben, um throw new MyError() verwenden zu können und mit instanceof MyError zu prüfen, welche Art von Fehler im Ausnahmehandler vorliegt. Das ergibt saubereren und konsistenteren Fehlerbehandlungscode.

Lesen Sie "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
• Stapelverfolgungs-API in der V8-Dokumentation