Window.reportError() — Methode · JavaScript-Referenz

Signatur

window.reportError(throwable)

Beschreibung

reportError() behandelt einen beliebigen Wert so, als wäre er als nicht abgefangene Ausnahme bis zur obersten Ebene durchgereicht worden. Der Browser löst ein ErrorEvent vom Typ error am globalen Objekt (window bzw. im Worker am self) aus. Dabei werden auch window.onerror und alle mit addEventListener("error", …) registrierten Handler aufgerufen. Ruft kein Handler preventDefault() auf, erscheint der Fehler als „Uncaught“ in der Entwicklerkonsole.

Anders als bei throw läuft die aktuelle Funktion ganz normal weiter. Das ist vor allem für Bibliotheken und Frameworks praktisch, die fremde Rückrufe ausführen, etwa Event-Emitter, Plugin-Systeme oder Schleifen über Observer. Ein Fehler in einem Rückruf soll dort nicht die übrigen blockieren, aber trotzdem sichtbar gemeldet werden und bei Monitoring-Tools wie Sentry ankommen, die an window.onerror hängen.

Früher behalf man sich mit setTimeout(() => { throw err; }). Dabei wird der Fehler aber erst später gemeldet und der Stack-Kontext wird verfälscht. reportError() meldet den Fehler dagegen sofort und synchron, und alle Listener laufen noch vor der nächsten Anweisung.

Parameter

Name	Typ	Default	Beschreibung
$throwable Pflicht	any (typischerweise Error)		Der zu meldende Wert. Meist ist das ein `Error`-Objekt, es geht aber auch jeder andere Wert. Er steht im Handler unter `event.error` zur Verfügung. Bei `Error`-Objekten werden `message`, `filename`, `lineno` und `colno` des Events daraus abgeleitet.

Rückgabewert

Typ

void

Beschreibung

Gibt undefined zurück. Ohne Argument wird ein TypeError geworfen.

Beispiele

Fehler melden, ohne die Ausführung abzubrechen

window.addEventListener('error', (event) => {
  console.log('Gemeldet:', event.message);
  console.log('Gleiches Objekt:', event.error instanceof TypeError);
});

reportError(new TypeError('Ungültige Konfiguration'));
console.log('Code läuft weiter');

Gemeldet: Uncaught TypeError: Ungültige Konfiguration Gleiches Objekt: true Code läuft weiter

Event-Emitter: fehlerhafte Listener isolieren

class Emitter {
  #listeners = new Set();
  on(fn) { this.#listeners.add(fn); }
  emit(data) {
    for (const fn of this.#listeners) {
      try {
        fn(data);
      } catch (err) {
        // Fehler melden, aber die übrigen Listener trotzdem ausführen
        reportError(err);
      }
    }
  }
}

const bus = new Emitter();
bus.on(() => { throw new Error('Listener A kaputt'); });
bus.on((d) => console.log('Listener B erhielt:', d));
bus.emit('ping');

Uncaught Error: Listener A kaputt (in der Konsole) Listener B erhielt: ping

Zentrales Fehler-Logging mit onerror und Unterdrücken der Konsolenausgabe

window.onerror = (message, source, lineno, colno, error) => {
  navigator.sendBeacon('/api/log', JSON.stringify({
    message,
    stack: error?.stack ?? null,
  }));
  return true; // true unterdrückt die Standardausgabe in der Konsole
};

const ladeEinstellungen = () => {
  try {
    return JSON.parse(localStorage.getItem('settings') ?? '{}');
  } catch (err) {
    reportError(err); // wird protokolliert, dann weiter mit Standardwerten
    return {};
  }
};

console.log(ladeEinstellungen());

{}

Nutzung im Web Worker

// worker.js
self.addEventListener('error', (e) => {
  console.log('Worker-Fehler:', e.error.message);
});

self.onmessage = ({ data }) => {
  if (typeof data !== 'number') {
    reportError(new RangeError(`Zahl erwartet, erhalten: ${typeof data}`));
    return;
  }
  self.postMessage(data * 2);
};

Worker-Fehler: Zahl erwartet, erhalten: string

// Wichtig · Fallstricke

Kompatibilität: Die Methode ist seit 2022 in allen aktuellen Browsern verfügbar (Chrome/Edge 95, Firefox 93, Safari 15.4). Für ältere Umgebungen bietet sich ein Fallback an: const report = globalThis.reportError ?? ((e) => setTimeout(() => { throw e; }));.
Node.js: Dort gibt es kein globales reportError(). Als Gegenstück dienen process.emit('uncaughtException', err) oder ein Logger.
Kein Ersatz für throw: Der Aufrufer bekommt vom Fehler nichts mit. Setzen Sie die Methode nur ein, wenn der Fehler bewusst nicht weitergereicht werden soll.
Kein unhandledrejection: Es wird nur das error-Event ausgelöst, auch wenn der Fehler aus einem Promise stammt.
Synchron: Die Handler laufen sofort. Wirft ein onerror-Handler selbst einen Fehler, wird dieser nicht rekursiv gemeldet.
Andere Werte als Error: Bei Strings oder Objekten fehlen filename und lineno oder sind leer, und es gibt keinen Stacktrace. Übergeben Sie deshalb möglichst Error-Instanzen.
Datenschutz: Wer gemeldete Fehler an einen Server schickt, sollte Stacktraces und Nachrichten auf personenbezogene Daten prüfen.

Siehe auch

try...catch throw Error Window.resizeTo() Window.setInterval()