Error

Beschreibung

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

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

Fehlertypen

Neben dem generischen Error-Konstruktor gibt es weitere Kernfehlertypen in JavaScript. Für klientseitige Ausnahmen siehe Behandlungsanweisungen für Ausnahmen.

EvalError

Erstellt eine Instanz, die einen Fehler darstellt, der in Bezug auf die globale 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 liegt.

ReferenceError

Erstellt eine Instanz, die einen Fehler darstellt, der auftritt, wenn auf eine ungültige Referenz zugegriffen 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 erhalten.

AggregateError

Erstellt eine Instanz, die mehrere Fehler in einem einzigen Fehler darstellt, wenn mehrere Fehler von einer Operation gemeldet werden müssen, beispielsweise durch Promise.any().

InternalError

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

Konstruktor

Error()

Erstellt ein neues Error-Objekt.

Statische Eigenschaften

Error.stackTraceLimit

Eine nicht standardisierte numerische Eigenschaft, die begrenzt, wie viele Stack-Frames in einem Fehler-Stack-Trace enthalten sind.

Statische Methoden

Error.captureStackTrace()

Eine nicht standardisierte Funktion, die die Eigenschaft stack auf dem bereitgestellten Objekt erstellt.

Error.isError()

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

Error.prepareStackTrace() Optional

Eine nicht standardisierte Funktion, die, falls vom Benutzer bereitgestellt, von der JavaScript-Engine für geworfene Ausnahmen aufgerufen wird, um dem Benutzer benutzerdefiniertes Formatieren von Stack-Traces zu ermöglichen. Siehe die V8 Stack Trace API Dokumentation.

Instanzeigenschaften

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

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 bieten ihre eigenen name-Eigenschaften.

Error.prototype.stack

Eine nicht standardisierte Eigenschaft für einen Stack-Trace.

Diese Eigenschaften sind eigene Eigenschaften jeder Error-Instanz.

cause

Fehlerursache, die den Grund angibt, warum der aktuelle Fehler geworfen 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

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

fileName

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

lineNumber

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

message

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

Instanzmethoden

Error.prototype.toString()

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

Beispiele

Werfen eines generischen Fehlers

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

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

Behandlung eines spezifischen Fehlertyps

Sie können sich entscheiden, nur spezifische 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;
  }
}

Unterscheidung zwischen ähnlichen Fehlern

Manchmal kann ein Codeblock aus Gründen fehlschlagen, die eine unterschiedliche Behandlung erfordern, aber sehr ähnliche Fehler werfen (d.h. mit dem gleichen Typ und der gleichen Meldung).

Wenn Sie keine Kontrolle über die ursprünglichen Fehler haben, die geworfen werden, können Sie diese abfangen und neue Error-Objekte werfen, die spezifischere Nachrichten haben. Der ursprüngliche Fehler sollte dem neuen Error-Objekt im options-Parameter des Konstruktors als seine cause-Eigenschaft übergeben werden. Dies stellt sicher, dass der ursprüngliche Fehler und der Stack-Trace in höheren try/catch-Blöcken 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, wenn super() aufgerufen wird. Der Error()-Basisklassenkonstruktor liest options.cause und definiert die cause-Eigenschaft auf der neuen Fehlerinstanz.

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

Benutzerdefinierte Fehlertypen

Sie möchten möglicherweise Ihre eigenen Fehlertypen definieren, die von Error abgeleitet sind, um throw new MyError() verwenden zu können und den Fehlertyp im Ausnahmehandler mit instanceof MyError zu überprüfen. Dies führt zu einer saubereren und konsistenteren Fehlerbehandlungslogik.

Sehen Sie "Was ist eine gute Methode, um Error in JavaScript zu erweitern?" 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
}

Spezifikationen

Browser-Kompatibilität

Siehe auch

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