Error.isError() — Methode · JavaScript-Referenz

Signatur

Error.isError(value)

Beschreibung

Error.isError() prüft, ob der übergebene Wert ein echtes Error-Objekt ist. Das trifft auf alle Objekte zu, die mit Error, einem eingebauten Fehlertyp (TypeError, RangeError, AggregateError …) oder einer von Error abgeleiteten Klasse erzeugt wurden. Intern prüft die Methode den internen Slot [[ErrorData]], der nur beim Erzeugen durch einen Error-Konstruktor angelegt wird. Die Prototypkette spielt dabei keine Rolle.

Genau darin liegt der Vorteil gegenüber value instanceof Error. instanceof schlägt fehl, wenn der Fehler aus einem anderen Realm stammt, etwa aus einem iframe, einem vm-Kontext in Node.js oder einer ShadowRealm. Dort gibt es eine eigene Error-Konstruktorfunktion. Umgekehrt lässt sich instanceof leicht täuschen, zum Beispiel mit Object.create(Error.prototype) oder mit Symbol.hasInstance. Auch Object.prototype.toString.call(value) === "[object Error]" ist unzuverlässig, weil man das Ergebnis über Symbol.toStringTag fälschen kann.

Einsatzgebiete sind vor allem Bibliotheken, Logger, Serialisierer (z. B. für structuredClone oder postMessage) und zentrale catch-Handler. In JavaScript kann jeder beliebige Wert geworfen werden: Strings, Zahlen, null oder einfache Objekte. Mit Error.isError() lässt sich zuverlässig unterscheiden, ob Eigenschaften wie stack, message oder cause sinnvoll ausgewertet werden können.

Parameter

Name	Typ	Default	Beschreibung
$value Pflicht	any		Der zu prüfende Wert. Er kann beliebigen Typs sein. Primitive Werte ergeben immer `false`.

Rückgabewert

Typ

boolean

Beschreibung

true, wenn value ein echtes Error-Objekt ist (mit internem [[ErrorData]]-Slot, auch aus einem anderen Realm). Sonst false. Die Methode wirft keine Ausnahme.

Beispiele

Grundlegende Prüfungen

console.log(Error.isError(new Error('Fehler')));      // echter Error
console.log(Error.isError(new TypeError('Typ')));     // eingebauter Untertyp
console.log(Error.isError({ message: 'x', stack: '' })); // nur ähnlich aussehend
console.log(Error.isError('Fehler'));                  // String
console.log(Error.isError(null));

class ValidationError extends Error {}
console.log(Error.isError(new ValidationError('ungültig')));

true true false false false true

Fälschungen erkennen, die instanceof täuschen

const fake = Object.create(Error.prototype);
console.log(fake instanceof Error);   // Prototypkette passt
console.log(Error.isError(fake));     // kein [[ErrorData]]

const tagged = { [Symbol.toStringTag]: 'Error' };
console.log(Object.prototype.toString.call(tagged));
console.log(Error.isError(tagged));

true false [object Error] false

Robuster catch-Handler für beliebige geworfene Werte

const normalizeError = (thrown) => {
  if (Error.isError(thrown)) return thrown;
  // Nicht-Error-Werte in einen echten Error verpacken
  return new Error(`Nicht-Error geworfen: ${String(thrown)}`, { cause: thrown });
};

const riskyTask = async () => {
  throw 'Zeitüberschreitung'; // schlechter Stil, kommt aber vor
};

try {
  await riskyTask();
} catch (e) {
  const err = normalizeError(e);
  console.log(err.message);
  console.log(err.cause);
}

Nicht-Error geworfen: Zeitüberschreitung Zeitüberschreitung

Fehler aus einem anderen Realm (iframe) prüfen

const iframe = document.createElement('iframe');
document.body.append(iframe);
const ForeignError = iframe.contentWindow.Error;
const foreign = new ForeignError('aus dem iframe');

console.log(foreign instanceof Error);  // anderer Konstruktor
console.log(Error.isError(foreign));    // realmübergreifend korrekt
iframe.remove();

false true

// Wichtig · Fallstricke

Kompatibilität: Die Methode ist sehr neu (ES2026, Stage 4 im Jahr 2025). Ältere Browser und Node.js-Versionen vor 24 kennen sie nicht. Vorher mit typeof Error.isError === 'function' prüfen oder ein Polyfill verwenden, z. B. aus core-js oder es-shims. Polyfills können den internen Slot aber nur annähernd prüfen. Auch in TypeScript fehlt die Typdefinition eventuell noch, falls lib nicht auf esnext gesetzt ist.
DOMException: In modernen Browsern besitzen DOMException-Objekte ebenfalls [[ErrorData]]. Dann liefert Error.isError(new DOMException()) den Wert true. Bei älteren Implementierungen kann das abweichen.
Kein Type-Narrowing auf Unterklassen: Die Methode sagt nur, ob ein Wert ein Error ist, nicht welcher. Für bestimmte Typen weiterhin instanceof oder err.name verwenden.
Nachträgliche Änderungen: Das Ergebnis bleibt true, auch wenn der Prototyp eines echten Errors mit Object.setPrototypeOf verändert wird. Umgekehrt wird ein normales Objekt nie zu einem Error, auch wenn man ihm message und stack gibt.
Proxys um ein Error-Objekt ergeben false, weil der Proxy selbst keinen [[ErrorData]]-Slot hat.

Siehe auch

Error instanceof Array.isArray() Error.captureStackTrace() try...catch throw