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()
oderdecodeURI()
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 derError
-Konstruktor. Error.prototype.name
-
Stellt den Namen des Fehlertyps dar. Für
Error.prototype.name
ist der Initialwert"Error"
. Unterklassen wieTypeError
undSyntaxError
haben ihre eigenenname
-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 alscause
-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:
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:
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()
):
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.
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.
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 GitHubdesktop | mobile | server | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Error | ||||||||||||||
Error() constructor | ||||||||||||||
fileName parameter | ||||||||||||||
lineNumber parameter | ||||||||||||||
options.cause parameter | ||||||||||||||
captureStackTrace | ||||||||||||||
cause | ||||||||||||||
Cause is displayed in console | ||||||||||||||
columnNumber | ||||||||||||||
fileName | ||||||||||||||
lineNumber | ||||||||||||||
message | ||||||||||||||
name | ||||||||||||||
Error is serializable | ||||||||||||||
stack | ||||||||||||||
stackTraceLimit | ||||||||||||||
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
- Polyfill von
Error
mitcause
-Unterstützung incore-js
throw
try...catch
- Stack-Trace-API in der V8-Dokumentation