Error

Beschreibung

Bei Laufzeitfehlern werden neue Error-Objekte erstellt und ausgelöst.

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

Fehlertypen

Neben dem allgemeinen Error-Konstruktor gibt es in JavaScript weitere zentrale Fehlerkonstruktoren. Informationen zu Ausnahmen auf der Clientseite finden Sie unter Anweisungen zur Ausnahmebehandlung.

EvalError

Erstellt eine Instanz, die einen Fehler im Zusammenhang mit der globalen Funktion eval() repräsentiert.

RangeError

Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn eine numerische Variable oder ein numerischer Parameter außerhalb des gültigen Bereichs liegt.

ReferenceError

Erstellt eine Instanz, die einen Fehler repräsentiert, der beim Dereferenzieren einer ungültigen Referenz auftritt.

SyntaxError

Erstellt eine Instanz, die einen Syntaxfehler repräsentiert.

TypeError

Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn eine Variable oder ein Parameter keinen gültigen Typ hat.

URIError

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

AggregateError

Erstellt eine Instanz, die mehrere Fehler in einem einzigen Fehler zusammenfasst, wenn eine Operation mehrere Fehler melden muss, beispielsweise Promise.any().

InternalError

Erstellt eine Instanz, die einen Fehler repräsentiert, der auftritt, wenn die JavaScript-Engine einen internen Fehler auslöst, beispielsweise „too much recursion“.

Konstruktor

Error()

Erstellt ein neues Error-Objekt.

Statische Eigenschaften

Error.stackTraceLimit

Eine nicht standardisierte numerische Eigenschaft, die begrenzt, wie viele Stack-Frames in einen Fehler-Stack-Trace aufgenommen werden.

Statische Methoden

Error.captureStackTrace()

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

Error.isError()

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

Error.prepareStackTrace() Optional

Eine nicht standardisierte Funktion, die von der JavaScript-Engine bei ausgelösten Ausnahmen aufgerufen wird, sofern sie im Benutzercode bereitgestellt wurde. Damit lässt sich die Formatierung von Stack-Traces anpassen. Weitere Informationen finden Sie in der Dokumentation zur V8 Stack Trace API.

Instanzeigenschaften

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

Error.prototype.constructor

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

Error.prototype.name

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

Error.prototype.stack

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

Die folgenden Eigenschaften gehören jeweils zu einer einzelnen Error-Instanz.

cause

Die Fehlerursache, die angibt, warum der aktuelle Fehler ausgelöst wurde – üblicherweise ein anderer, zuvor abgefangener Fehler. Bei benutzerseitig erstellten Error-Objekten ist dies der Wert der Eigenschaft cause im zweiten Argument des Konstruktors.

columnNumber

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

fileName

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

lineNumber

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

message

Die Fehlermeldung. Bei benutzerseitig erstellten Error-Objekten ist dies die Zeichenfolge, die als erstes Argument an den Konstruktor übergeben wurde.

Instanzmethoden

Error.prototype.toString()

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

Beispiele

Einen allgemeinen Fehler auslösen

Üblicherweise erstellen Sie ein Error-Objekt, um es mit dem Schlüsselwort 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}`);
}

Einen bestimmten Fehlertyp behandeln

Sie können gezielt nur bestimmte Fehlertypen behandeln, indem Sie den Fehlertyp mit dem Schlüsselwort instanceof prüfen:

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;
  }
}

Zwischen ähnlichen Fehlern unterscheiden

Manchmal kann ein Codeblock aus Gründen fehlschlagen, die eine unterschiedliche Behandlung erfordern, obwohl dabei sehr ähnliche Fehler ausgelöst werden (d.h. Fehler mit demselben Typ und derselben Meldung).

Wenn Sie keinen Einfluss auf die ursprünglich ausgelösten Fehler haben, können Sie diese abfangen und neue Error-Objekte mit aussagekräftigeren Meldungen auslösen. Der ursprüngliche Fehler sollte dem neuen Error im Parameter options des Konstruktors als Eigenschaft cause übergeben werden. So stehen der ursprüngliche Fehler und sein Stack-Trace übergeordneten try/catch-Blöcken zur Verfügung.

Das folgende Beispiel zeigt dies für zwei Methoden, die andernfalls 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;
  }
}

Auch benutzerdefinierte Fehlertypen können die Eigenschaft cause verwenden, sofern der Konstruktor der Unterklasse beim Aufruf von super() den Parameter options übergibt. Der Konstruktor der Basisklasse Error() liest options.cause und definiert die Eigenschaft cause 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 können eigene, von Error abgeleitete Fehlertypen definieren. So können Sie mit throw new MyError() einen Fehler auslösen und im Ausnahmehandler mit instanceof MyError dessen Typ prüfen. Dadurch wird der Code zur Fehlerbehandlung übersichtlicher und einheitlicher.

Eine ausführliche Diskussion finden Sie auf Stack Overflow unter „What's a good way to extend Error in JavaScript?“.

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 für Error mit Unterstützung für cause in core-js
• es-shims-Polyfill für Error und cause
• throw
• try...catch
• Stack Trace API in der V8-Dokumentation