Error - JavaScript | MDN

Seitenleiste umschalten

Farbschema

Systemeinstellung
Hell
Dunkel

Deutsch

Sprache merken Mehr erfahren

Error

Baseline Weitgehend verfügbar *

Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Juli 2015 browserübergreifend verfügbar.

* Einige Teile dieser Funktion werden möglicherweise unterschiedlich gut unterstützt.

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

In diesem Artikel

Beschreibung

Laufzeitfehler führen 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. Für klientseitige Ausnahmen siehe Behandlungsanweisungen für 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 außerhalb seines 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, wenn encodeURI() oder decodeURI() ungültige Parameter erhalten.

AggregateError

Erstellt eine Instanz, die mehrere Fehler in einem einzigen Fehler darstellt, wenn mehrere Fehler von einer Operation gemeldet werden müssen, 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 zurück, 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 für geworfene Ausnahmen aufgerufen wird, um dem Benutzer benutzerdefiniertes Formatieren von Stack-Traces zu ermöglichen. 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. Für Error-Instanzen ist der Anfangswert der Error-Konstruktor.

Error.prototype.name

Repräsentiert den Namen für den Fehlertyp. Für Error.prototype.name ist der Anfangswert "Error". Unterklassen wie TypeError und SyntaxError bieten ihre eigenen name-Eigenschaften.

Error.prototype.stack

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

columnNumber

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

fileName

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

lineNumber

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

message

Fehlermeldung. Für benutzererstellte Error-Objekte 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 repräsentiert. Überschreibt die Methode Object.prototype.toString().

Beispiele

Werfen eines generischen Fehlers

Üblicherweise erstellen Sie ein Error-Objekt mit der Absicht, 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}`);
}

Behandlung eines spezifischen Fehlertyps

Sie können sich entscheiden, nur spezifische Fehlertypen zu behandeln, indem Sie den Fehlertyp mit dem Schlüsselwort instanceof 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 zwischen ähnlichen Fehlern

Manchmal kann ein Codeblock aus Gründen 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 ursprünglichen Fehler haben, die geworfen werden, können Sie diese abfangen und neue Error-Objekte werfen, die spezifischere Nachrichten haben. Der ursprüngliche Fehler sollte dem neuen Error-Objekt im options-Parameter des Konstruktors als seine cause-Eigenschaft übergeben werden. Dies stellt sicher, dass der ursprüngliche Fehler und der 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 bevorzugt die Fehlerursache nutzen, um zwischen verschiedenen geworfenen Fehlern zu unterscheiden — anstatt Ihre Nutzer zu bitten, die Fehlermeldung zu analysieren. Siehe die Seite zur Fehlerursache für ein Beispiel.

Benutzerdefinierte Fehlertypen können 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.

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

Sie möchten möglicherweise Ihre eigenen Fehlertypen definieren, die von Error abgeleitet sind, um throw new MyError() verwenden zu können und den Fehlertyp im Ausnahmehandler mit instanceof MyError zu überprüfen. Dies führt zu einer saubereren und konsistenteren Fehlerbehandlungslogik.

Sehen Sie "Was ist eine gute Methode, um Error in JavaScript zu erweitern?" auf Stack Overflow für eine ausführliche Diskussion.

Warnung: Die eingebaute Unterklassenbildung kann nicht zuverlässig in Vor-ES6-Code transpiliert werden, da es keine Möglichkeit gibt, die Basisklasse mit einem bestimmten new.target ohne Reflect.construct() zu erstellen. Sie benötigen zusätzliche Konfiguration oder müssen manuell Object.setPrototypeOf(this, CustomError.prototype) am Ende des Konstruktors aufrufen; andernfalls wird die konstruierte Instanz keine CustomError-Instanz sein. Siehe das TypeScript FAQ für weitere Informationen.

Hinweis: Einige Browser enthalten den CustomError-Konstruktor im Stack-Trace bei Verwendung von ES2015-Klassen.

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
}

Polyfill von Error mit Unterstützung für cause in core-js
es-shims polyfill von Error cause
throw
try...catch
Stack Trace API in den V8-Dokumenten

Help improve MDN

War diese Übersetzung hilfreich?

Ja Nein

Erfahren Sie, wie Sie beitragen können Diese Seite wurde automatisch aus dem Englischen übersetzt.

Übersetzung auf GitHub anzeigen • Fehler mit dieser Übersetzung melden

Standard eingebaute Objekte
Error
Konstruktor
1. Error()
Statische Methoden
1. captureStackTrace()
2. isError()
Statische Eigenschaften
1. stackTraceLimit
Instanzmethoden
1. toString()
Instanzeigenschaften
1. cause
2. columnNumber
3. fileName
4. lineNumber
5. message
6. name
7. stack
Vererbung
Object/Function
Statische Methoden
1. apply()
2. bind()
3. call()
4. toString()
5. [Symbol.hasInstance]()
Statische Eigenschaften
1. displayName
2. length
3. name
4. prototype
5. arguments
6. caller
Instanzmethoden
1. __defineGetter__()
2. __defineSetter__()
3. __lookupGetter__()
4. __lookupSetter__()
5. hasOwnProperty()
6. isPrototypeOf()
7. propertyIsEnumerable()
8. toLocaleString()
9. toString()
10. valueOf()
Instanzeigenschaften
1. __proto__
2. constructor
Verwandte Seiten
AggregateError
EvalError
InternalError
RangeError
ReferenceError
SyntaxError
TypeError
URIError