Error

Beschreibung

Bei Laufzeitfehlern werden neue Error-Objekte erstellt und ausgelst.

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() reprsentiert.

RangeError

Erstellt eine Instanz, die einen Fehler reprsentiert, der auftritt, wenn eine numerische Variable oder ein numerischer Parameter auerhalb des gltigen Bereichs liegt.

ReferenceError

Erstellt eine Instanz, die einen Fehler reprsentiert, der beim Dereferenzieren einer ungltigen Referenz auftritt.

SyntaxError

Erstellt eine Instanz, die einen Syntaxfehler reprsentiert.

TypeError

Erstellt eine Instanz, die einen Fehler reprsentiert, der auftritt, wenn eine Variable oder ein Parameter keinen gltigen Typ hat.

URIError

Erstellt eine Instanz, die einen Fehler reprsentiert, der auftritt, wenn an encodeURI() oder decodeURI() ungltige 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 reprsentiert, der auftritt, wenn die JavaScript-Engine einen internen Fehler auslst, 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 zurck, wenn das Argument ein Fehler ist, andernfalls false.

Error.prepareStackTrace() Optional

Eine nicht standardisierte Funktion, die von der JavaScript-Engine bei ausgelsten Ausnahmen aufgerufen wird, sofern sie im Benutzercode bereitgestellt wurde. Damit lsst 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. Fr Error-Instanzen ist der Anfangswert der Konstruktor Error.

Error.prototype.name

Reprsentiert den Namen des Fehlertyps. Fr Error.prototype.name ist der Anfangswert "Error". Unterklassen wie TypeError und SyntaxError stellen eigene name-Eigenschaften bereit.

Error.prototype.stack

Eine nicht standardisierte Eigenschaft fr einen Stack-Trace.

Die folgenden Eigenschaften gehren jeweils zu einer einzelnen Error-Instanz.

cause

Die Fehlerursache, die angibt, warum der aktuelle Fehler ausgelst 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 fr die Spaltennummer in der Zeile, die diesen Fehler verursacht hat.

fileName

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

lineNumber

Eine nicht standardisierte Mozilla-Eigenschaft fr 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 zurck, die das angegebene Objekt reprsentiert. berschreibt die Methode Object.prototype.toString().

Beispiele

Einen allgemeinen Fehler auslsen

blicherweise erstellen Sie ein Error-Objekt, um es mit dem Schlsselwort throw auszulsen. Sie knnen 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 knnen gezielt nur bestimmte Fehlertypen behandeln, indem Sie den Fehlertyp mit dem Schlsselwort instanceof prfen:

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 Grnden fehlschlagen, die eine unterschiedliche Behandlung erfordern, obwohl dabei sehr hnliche Fehler ausgelst werden (d.h. Fehler mit demselben Typ und derselben Meldung).

Wenn Sie keinen Einfluss auf die ursprnglich ausgelsten Fehler haben, knnen Sie diese abfangen und neue Error-Objekte mit aussagekrftigeren Meldungen auslsen. Der ursprngliche Fehler sollte dem neuen Error im Parameter options des Konstruktors als Eigenschaft cause bergeben werden. So stehen der ursprngliche Fehler und sein Stack-Trace bergeordneten try/catch-Blcken zur Verfgung.

Das folgende Beispiel zeigt dies fr zwei Methoden, die andernfalls mit hnlichen Fehlern fehlschlagen wrden (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 knnen 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 knnen eigene, von Error abgeleitete Fehlertypen definieren. So knnen Sie mit throw new MyError() einen Fehler auslsen und im Ausnahmehandler mit instanceof MyError dessen Typ prfen. Dadurch wird der Code zur Fehlerbehandlung bersichtlicher und einheitlicher.

Eine ausfhrliche 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-Kompatibilitt

Siehe auch

• Polyfill fr Error mit Untersttzung fr cause in core-js
• es-shims-Polyfill fr Error und cause
• throw
• try...catch
• Stack Trace API in der V8-Dokumentation