Error

Beschreibung

Laufzeitfehler fhren 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. Fr klientseitige Ausnahmen siehe Behandlungsanweisungen fr 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 auerhalb seines gltigen Bereichs liegt.

ReferenceError

Erstellt eine Instanz, die einen Fehler darstellt, der auftritt, wenn auf eine ungltige 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 gltigen Typ ist.

URIError

Erstellt eine Instanz, die einen Fehler darstellt, der auftritt, wenn encodeURI() oder decodeURI() ungltige Parameter erhalten.

AggregateError

Erstellt eine Instanz, die mehrere Fehler in einem einzigen Fehler darstellt, wenn mehrere Fehler von einer Operation gemeldet werden mssen, 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 zurck, 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 fr geworfene Ausnahmen aufgerufen wird, um dem Benutzer benutzerdefiniertes Formatieren von Stack-Traces zu ermglichen. 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. Fr Error-Instanzen ist der Anfangswert der Error-Konstruktor.

Error.prototype.name

Reprsentiert den Namen fr den Fehlertyp. Fr Error.prototype.name ist der Anfangswert "Error". Unterklassen wie TypeError und SyntaxError bieten ihre eigenen name-Eigenschaften.

Error.prototype.stack

Eine nicht standardisierte Eigenschaft fr 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. Fr benutzererstellte Error-Objekte ist dies der Wert, der als cause-Eigenschaft des zweiten Arguments des Konstruktors bereitgestellt wird.

columnNumber

Eine nicht standardisierte Mozilla-Eigenschaft fr die Spaltennummer in der Zeile, die diesen Fehler ausgelst hat.

fileName

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

lineNumber

Eine nicht standardisierte Mozilla-Eigenschaft fr die Zeilennummer in der Datei, die diesen Fehler ausgelst hat.

message

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

Instanzmethoden

Error.prototype.toString()

Gibt einen String zurck, der das spezifizierte Objekt reprsentiert. berschreibt die Methode Object.prototype.toString().

Beispiele

Werfen eines generischen Fehlers

blicherweise erstellen Sie ein Error-Objekt mit der Absicht, es mit dem throw-Schlsselwort zu werfen. Sie knnen 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 knnen sich entscheiden, nur spezifische Fehlertypen zu behandeln, indem Sie den Fehlertyp mit dem Schlsselwort 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 Grnden 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 ursprnglichen Fehler haben, die geworfen werden, knnen Sie diese abfangen und neue Error-Objekte werfen, die spezifischere Nachrichten haben. Der ursprngliche Fehler sollte dem neuen Error-Objekt im options-Parameter des Konstruktors als seine cause-Eigenschaft bergeben werden. Dies stellt sicher, dass der ursprngliche Fehler und der Stack-Trace in hheren try/catch-Blcken verfgbar sind.

Das folgende Beispiel zeigt dies fr zwei Methoden, die ansonsten 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;
  }
}

Benutzerdefinierte Fehlertypen knnen 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 mchten mglicherweise Ihre eigenen Fehlertypen definieren, die von Error abgeleitet sind, um throw new MyError() verwenden zu knnen und den Fehlertyp im Ausnahmehandler mit instanceof MyError zu berprfen. Dies fhrt zu einer saubereren und konsistenteren Fehlerbehandlungslogik.

Sehen Sie "Was ist eine gute Methode, um Error in JavaScript zu erweitern?" auf Stack Overflow fr eine ausfhrliche 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-Kompatibilitt

Siehe auch

• Polyfill von Error mit Untersttzung fr cause in core-js
• es-shims polyfill von Error cause
• throw
• try...catch
• Stack Trace API in den V8-Dokumenten