Error

Baseline Widely available *

This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.

* Some parts of this feature may have varying levels of support.

Error-Objekte werden geworfen, wenn Laufzeitfehler auftreten. Das Error-Objekt kann auch als Basisobjekt für benutzerdefinierte Ausnahmen verwendet werden. Unten finden Sie die standardmäßigen eingebauten Fehlertypen.

Beschreibung

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

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

Fehlertypen

Neben dem generischen Error-Konstruktor gibt es weitere Kernfehlerkonstruktoren in JavaScript. Für clientseitige Ausnahmen siehe Anweisungen zur Ausnahmebehandlung.

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, wenn eine numerische Variable oder ein Parameter außerhalb seines gültigen Bereichs liegt.

ReferenceError

Erstellt eine Instanz, die einen Fehler darstellt, der beim Dereferenzieren eines ungültigen Verweises auftritt.

SyntaxError

Erstellt eine Instanz, die einen Syntaxfehler darstellt.

TypeError

Erstellt eine Instanz, die einen Fehler darstellt, wenn eine Variable oder ein Parameter keinen gültigen Typ hat.

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 ein Vorgang 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. "zu viele Rekursionen".

Konstruktor

Error()

Erstellt ein neues Error-Objekt.

Statische Eigenschaften

Error.stackTraceLimit Nicht standardisiert

Eine nicht-standardmäßige numerische Eigenschaft, die begrenzt, wie viele Stack-Frames in eine Fehler-Stack-Trace eingeschlossen werden.

Statische Methoden

Error.captureStackTrace() Nicht standardisiert

Eine nicht-standardmäßige Funktion, die die stack-Eigenschaft für ein bereitgestelltes Objekt erstellt.

Error.prepareStackTrace() Nicht standardisiert Optional

Eine nicht-standardmäßige Funktion, die, wenn sie vom Benutzer bereitgestellt wird, von der JavaScript-Engine für geworfene Ausnahmen aufgerufen wird. Sie erlaubt die benutzerdefinierte Formatierung von Stack-Traces. Siehe die V8 Stack Trace API-Dokumentation.

Instanz-Eigenschaften

Die folgenden Eigenschaften sind auf Error.prototype definiert und werden von allen Error-Instanzen gemeinsam verwendet.

Error.prototype.constructor

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

Error.prototype.name

Stellt den Namen des Fehlertyps dar. Für Error.prototype.name ist der Initialwert "Error". Unterklassen wie TypeError und SyntaxError haben ihre eigenen name-Eigenschaften.

Error.prototype.stack Nicht standardisiert

Eine nicht-standardmäßige Eigenschaft für eine Stack-Trace.

Die folgenden Eigenschaften sind eigene Eigenschaften jeder Error-Instanz.

cause

Fehlerursache, die den Grund angibt, warum der aktuelle Fehler geworfen wird – normalerweise ein anderer abgefangener Fehler. Für benutzerdefinierte Error-Objekte ist dies der Wert, der als cause-Eigenschaft des zweiten Konstruktorarguments bereitgestellt wird.

columnNumber Nicht standardisiert

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

fileName Nicht standardisiert

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

lineNumber Nicht standardisiert

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

message

Fehlermeldung. Für benutzerdefinierte Error-Objekte ist dies die Zeichenkette, die als erstes Argument des Konstruktors bereitgestellt wird.

Instanz-Methoden

Error.prototype.toString()

Gibt eine Zeichenkette zurück, die das spezifizierte Objekt darstellt. Überschreibt die Methode Object.prototype.toString().

Beispiele

Generischen Fehler werfen

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

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

Handhabung eines spezifischen Fehlertyps

Sie können wählen, nur spezifische Fehlertypen zu behandeln, indem Sie den Fehlertyp mit dem instanceof-Schlüsselwort testen:

js
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 ähnlicher Fehler

Manchmal kann ein Codeblock aus Gründen fehlschlagen, die unterschiedliche Behandlung erfordern, aber sehr ähnliche Fehler werfen (z. B. vom gleichen Typ und mit der gleichen Nachricht).

Wenn Sie keine Kontrolle über die ursprünglichen geworfenen Fehler haben, können Sie diese abfangen und neue Error-Objekte werfen, die spezifischere Nachrichten haben. Der ursprüngliche Fehler sollte an den neuen Error im options-Parameter des Konstruktors als dessen cause-Eigenschaft übergeben werden. Dies stellt sicher, dass der ursprüngliche Fehler und die 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()):

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

Hinweis: Wenn Sie eine Bibliothek erstellen, sollten Sie bevorzugen, die Fehlerursache zu verwenden, um zwischen verschiedenen geworfenen Fehlern zu unterscheiden – anstatt von Ihren Nutzern zu verlangen, die Fehlermeldung zu analysieren. Siehe die Seite über die Fehlerursache für ein Beispiel.

Benutzerdefinierte Fehlertypen können ebenfalls die cause-Eigenschaft verwenden, vorausgesetzt, die Konstruktoren der Unterklassen übergeben den options-Parameter beim Aufruf von super(). Der Konstruktor der Error()-Basis-Klasse liest options.cause und definiert die cause-Eigenschaft auf der neuen Fehlerinstanz.

js
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

Es kann gewünscht sein, eigene Fehlertypen von Error abzuleiten, um throw new MyError() auszuführen und mit instanceof MyError die Art des Fehlers im Ausnahmehandler zu prüfen. Dies führt zu saubererem und konsistenterem Fehlerbehandlungscode.

Siehe "What's a good way to extend Error in JavaScript?" auf Stack Overflow für eine detaillierte Diskussion.

Warnung: Eingebautes Subclassing kann nicht zuverlässig in prä-ES6-Code transpiliert werden, da es keinen Weg gibt, die Basisklasse mit einem bestimmten new.target zu konstruieren, ohne Reflect.construct(). Sie benötigen zusätzliche Konfiguration oder müssen Object.setPrototypeOf(this, CustomError.prototype) manuell am Ende des Konstruktors aufrufen. Andernfalls wird die erzeugte Instanz keine CustomError-Instanz sein. Weitere Informationen finden Sie in den TypeScript-FAQ.

Hinweis: Einige Browser beinhalten den CustomError-Konstruktor in der Stack-Trace, wenn sie ES2015-Klassen verwenden.

js
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

Specification
ECMAScript® 2025 Language Specification
# sec-error-objects

Browser-Kompatibilität

Report problems with this compatibility data on GitHub
desktopmobileserver
Chrome
Edge
Firefox
Opera
Safari
Chrome Android
Firefox for Android
Opera Android
Safari on iOS
Samsung Internet
WebView Android
WebView on iOS
Deno
Node.js
Error
Error() constructor
fileName parameter
Non-standard
lineNumber parameter
Non-standard
options.cause parameter
captureStackTrace
Non-standard
cause
Cause is displayed in console
Non-standard
columnNumber
Non-standard
fileName
Non-standard
lineNumber
Non-standard
message
name
Error is serializable
stack
Non-standard
stackTraceLimit
Non-standard
toString

Legend

Tip: you can click/tap on a cell for more information.

Full support
Full support
No support
No support
Non-standard. Check cross-browser support before using.
See implementation notes.
User must explicitly enable this feature.

Siehe auch