Fehler

Laufzeitfehler führen zur Erstellung und zum Werfen neuer Error-Objekte.

Error ist ein serialisierbares Objekt und kann daher mit structuredClone() geklont oder zwischen Arbeitern mit postMessage() kopiert werden.

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

EvalError

Erstellt eine Instanz, die einen Fehler darstellt, der bezüglich der globalen Funktion eval() auftritt.

RangeError

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

ReferenceError

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

SyntaxError

Erstellt eine Instanz, die einen Syntaxfehler darstellt.

TypeError

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

URIError

Erstellt eine Instanz, die einen Fehler darstellt, wenn encodeURI() oder decodeURI() ungültige Parameter erhalten.

AggregateError

Erstellt eine Instanz, die mehrere Fehler in einem einzigen Fehler zusammenfasst, wenn eine Operation mehrere Fehler melden muss, 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 standardisierte V8-Funktion, die die stack-Eigenschaft an einer Error-Instanz erstellt.

Error.stackTraceLimit Nicht standardisiert

Eine nicht standardisierte V8-Zahleneigenschaft, die angibt, wie viele Stapelrahmen in einer Fehler-Stacktrace enthalten sein sollen.

Error.prepareStackTrace() Nicht standardisiert Optional

Eine nicht standardisierte V8-Funktion, die, falls sie vom Benutzer bereitgestellt wird, von der V8-JavaScript-Engine für geworfene Ausnahmen aufgerufen wird und 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 Initialwert der Error Konstruktor.

Error.prototype.name

Repräsentiert den Namen des Fehlertyps. Für Error.prototype.name ist der Startwert "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 Eigenkapazitäten jeder Error-Instanz.

cause

Fehlerursache, die den Grund angibt, warum der aktuelle Fehler geworfen wurde — normalerweise ein anderer gefangener 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 Methode Object.prototype.toString().

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

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

Sie können 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 werfen (d. h. mit demselben Typ und derselben Nachricht).

Wenn Sie keine Kontrolle über die ursprünglich geworfenen Fehler haben, ist eine Möglichkeit, diese abzufangen und neue Error-Objekte zu werfen, die spezifischere Nachrichten enthalten. 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 Stapelverfolgung für höherstufige try/catch-Blöcke verfügbar sind.

Das Beispiel unten 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, vorausgesetzt, der Konstruktor der Unterklasse übergibt den options-Parameter beim Aufruf von super(). 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

Vielleicht möchten Sie eigene Fehlertypen definieren, die von Error abgeleitet sind, um throw new MyError() werfen zu können und mit instanceof MyError die Art des Fehlers im Ausnahmehandler zu überprüfen. Dies führt zu saubererem und konsistenterem Code zur Fehlerbehandlung.

Siehe "What's a good way to extend Error in JavaScript?" auf StackOverflow 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 (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