Error-Objekte werden ausgelöst, wenn Laufzeitfehler auftreten. DasError-Objekt kann auch als Basisobjekt für benutzerdefinierte Ausnahmen verwendet werden. Siehe unten für standardmäßig eingebaute Fehlertypen.

Beschreibung

Laufzeitfehler führen zur Erstellung und zum Auslösen neuerError-Objekte.

Error ist einserialisierbares Objekt und kann daher mitstructuredClone() geklont oder mitpostMessage() zwischenWorkers kopiert werden.

Fehlertypen

Neben dem allgemeinenError-Konstruktor gibt es andere Kernfehlerkonstruktoren in JavaScript. Für clientseitige Ausnahmen sieheAusnahmekontrollanweisungen.

EvalError

Erstellt eine Instanz, die einen Fehler darstellt, der im Zusammenhang mit der globalen Funktioneval() auftritt.

RangeError

Erstellt eine Instanz, die einen Fehler darstellt, der auftritt, wenn eine numerische Variable oder ein Parameter außerhalb des 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, wennencodeURI() oderdecodeURI() ungültige Parameter übergeben werden.

AggregateError

Erstellt eine Instanz, die mehrere Fehler in einem einzigen Fehler zusammenfasst, wenn eine Operation mehrere Fehler berichten muss, zum Beispiel durchPromise.any().

InternalErrorNicht standardisiert

Erstellt eine Instanz, die einen Fehler darstellt, der auftritt, wenn ein interner Fehler in der JavaScript-Engine ausgelöst wird, z.B. "zu viel Rekursion".

Konstruktor

Error()

Erstellt ein neuesError-Objekt.

Statische Eigenschaften

Error.stackTraceLimitNicht standardisiert

Eine nicht-standard numerische Eigenschaft, die begrenzt, wie viele Stack-Frames in einem Fehler-Stack-Trace enthalten sein sollen.

Statische Methoden

Error.captureStackTrace()

Eine nicht-standard Funktion, die diestack-Eigenschaft auf dem bereitgestellten Objekt erstellt.

Error.isError()

Gibttrue zurück, wenn das Argument ein Fehler ist, oderfalse anderenfalls.

Error.prepareStackTrace()Nicht standardisiertOptional

Eine nicht-standard Funktion, die, wenn sie von Benutzer-Code bereitgestellt wird, von der JavaScript-Engine für ausgelöste Ausnahmen aufgerufen wird, um dem Benutzer zu ermöglichen, benutzerdefinierte Formatierungen für Stack-Traces bereitzustellen. Siehe dieV8 Stack Trace API Dokumentation.

Instanzeigenschaften

Diese Eigenschaften sind aufError.prototype definiert und werden von allenError-Instanzen geteilt.

Error.prototype.constructor

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

Error.prototype.name

Repräsentiert den Namen für die Art des Fehlers. FürError.prototype.name ist der Anfangswert"Error". Unterklassen wieTypeError undSyntaxError bieten ihre eigenenname-Eigenschaften.

Error.prototype.stackNicht standardisiert

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

Diese Eigenschaften sind eigene Eigenschaften jederError-Instanz.

cause

Fehlerursache, die den Grund angibt, warum der aktuelle Fehler ausgelöst wird — normalerweise ein anderer gefangener Fehler. Bei benutzererstelltenError-Objekten ist dies der Wert, der als diecause-Eigenschaft des zweiten Arguments des Konstruktors bereitgestellt wird.

columnNumberNicht standardisiert

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

fileNameNicht standardisiert

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

lineNumberNicht standardisiert

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

message

Fehlermeldung. Bei benutzererstelltenError-Objekten 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 darstellt. Überschreibt dieObject.prototype.toString()-Methode.

Beispiele

Werfen eines allgemeinen Fehlers

Normalerweise erstellt man einError-Objekt mit der Absicht, es mit demthrow-Schlüsselwort auszulösen.Sie können den Fehler mit dertry...catch-Konstruktion behandeln:

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

Behandlung eines spezifischen Fehlertyps

Sie können sich dafür entscheiden, nur spezifische Fehlertypen zu behandeln, indem Sie den Fehlertyp mit deminstanceof-Schlüsselwort 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 scheitern, die eine unterschiedliche Behandlung erfordern, aber sehr ähnliche Fehler werfen (d.h. mit demselben Typ und derselben Meldung).

Wenn Sie keine Kontrolle über die ursprünglich geworfenen Fehler haben, ist eine Möglichkeit, sie abzufangen und neueError-Objekte mit spezifischeren Nachrichten zu werfen.Der ursprüngliche Fehler sollte imoptions-Parameter des Konstruktors als seinecause-Eigenschaft an das neueError übergeben werden. Dies stellt sicher, dass der ursprüngliche Fehler und der Stack-Trace für höherstufige try/catch-Blöcke verfügbar sind.

Das folgende Beispiel zeigt dies für zwei Methoden, die andernfalls mit ähnlichen Fehlern scheitern würden (doFailSomeWay() unddoFailAnotherWay()):

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 diecause-Eigenschaft verwenden, vorausgesetzt, dass der Konstruktor der Unterklassen denoptions-Parameter beim Aufruf vonsuper() übergibt. DerError()-Basis-Konstruktor wirdoptions.cause lesen und diecause-Eigenschaft an 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

Benutzerdefinierte Fehlertypen

Sie könnten Ihre eigenen Fehlertypen definieren, die sich vonError ableiten, umthrow new MyError() nutzen zu können und mitinstanceof MyError die Art des Fehlers im Ausnahmebehandler zu überprü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 eingehende 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 vonError mitcause-Unterstützung incore-js
• es-shims Polyfill von Errorcause
• throw
• try...catch
• Stack Trace API in den V8-Dokumenten