Error.prototype.name — Eigenschaft · JavaScript-Referenz

Signatur

Error.prototype.name

Beschreibung

Die Daten-Eigenschaft name liegt auf Error.prototype und hat den Anfangswert "Error". Alle Instanzen erben sie über die Prototypkette, sie ist also normalerweise keine eigene Eigenschaft des Fehlerobjekts. Die eingebauten Unterklassen wie TypeError, RangeError oder SyntaxError überschreiben sie auf ihrem eigenen Prototyp mit ihrem jeweiligen Klassennamen.

Die Eigenschaft ist beschreibbar (writable), nicht aufzählbar (non-enumerable) und konfigurierbar. Error.prototype.toString() nutzt name zusammen mit message, um die Zeichenkette "Name: Nachricht" zu bilden. Diese Form sieht man in Konsolenausgaben und Stacktraces.

In der Praxis braucht man name vor allem bei eigenen Fehlerklassen: Setzt man this.name im Konstruktor oder als Klassenfeld, erscheint der eigene Name in Logs. Außerdem lassen sich Fehler dann auch über Realm-Grenzen hinweg (iframes, Worker, serialisierte Fehler) unterscheiden, wo instanceof versagt.

Rückgabewert

Typ

string

Beschreibung

Der Name des Fehlertyps, z. B. "Error", "TypeError" oder ein selbst gesetzter Name wie "ValidationError".

Beispiele

Standardwerte eingebauter Fehlertypen

const fehler = [new Error('a'), new TypeError('b'), new RangeError('c')];
for (const err of fehler) {
  console.log(err.name, '|', String(err));
}
// name ist geerbt, keine eigene Eigenschaft
console.log(Object.hasOwn(fehler[0], 'name'));

Error | Error: a TypeError | TypeError: b RangeError | RangeError: c false

Eigene Fehlerklasse mit sprechendem Namen

class ValidationError extends Error {
  constructor(feld, message) {
    super(message);
    this.name = 'ValidationError';
    this.feld = feld;
  }
}

try {
  throw new ValidationError('email', 'Ungültige E-Mail-Adresse');
} catch (err) {
  console.log(err.name);
  console.log(err.toString());
}

ValidationError ValidationError: Ungültige E-Mail-Adresse

Fehler per name unterscheiden (z. B. AbortError bei fetch)

const controller = new AbortController();
setTimeout(() => controller.abort(), 10);

try {
  await fetch('https://example.com/langsam', { signal: controller.signal });
} catch (err) {
  if (err.name === 'AbortError') {
    console.log('Anfrage wurde abgebrochen');
  } else {
    throw err;
  }
}

Anfrage wurde abgebrochen

Name dynamisch aus dem Klassennamen ableiten

class AppError extends Error {
  constructor(message, options) {
    super(message, options);
    this.name = new.target.name;
  }
}
class NotFoundError extends AppError {}

const err = new NotFoundError('Benutzer 42 nicht gefunden');
console.log(err.name, err instanceof AppError);

NotFoundError true

// Wichtig · Fallstricke

Bei Unterklassen nicht vergessen: Ohne eigene Zuweisung erbt eine class MyError extends Error den Wert "Error" von Error.prototype. Die Ausgabe zeigt dann Error: … statt MyError: ….
this.name = new.target.name ist bequem. Minifier (Terser, esbuild) können Klassennamen aber verkürzen, deshalb ist ein fester String-Literal robuster.
Wird name per Zuweisung gesetzt, entsteht eine aufzählbare eigene Eigenschaft. Sie taucht dann in Object.keys() und JSON.stringify() auf. Wer das nicht will, definiert sie auf dem Prototyp oder per Object.defineProperty mit enumerable: false.
Wer Error.prototype.name direkt ändert, betrifft alle Fehler, die diesen Wert erben. Das sollte man nie tun.
Bei DOMException (z. B. AbortError, NotAllowedError) ist name die empfohlene Art, den Fehler zu erkennen. Das veraltete code sollte man dafür nicht mehr verwenden.
Der Vergleich per name klappt auch über iframes und Worker hinweg, instanceof dagegen nicht. Dafür ist name nicht fälschungssicher, denn jedes Objekt kann denselben Namen tragen.

Siehe auch

Error Error.prototype.toString() Error.prototype.stack TypeError DOMException throw