Error — Klasse · JavaScript-Referenz

Signatur

new Error(message, options)

Beschreibung

Error-Objekte werden geworfen, wenn Laufzeitfehler auftreten. Das Error-Objekt kann auch als Basisobjekt für benutzerdefinierte Ausnahmen verwendet werden. Siehe unten für die standardmäßig eingebauten Fehlertypen.

Laufzeitfehler führen dazu, dass neue Error-Objekte erstellt und geworfen werden.

Error ist ein serializable object, kann also mit structuredClone() geklont oder mittels postMessage() zwischen Workers kopiert werden.

Fehlertypen

Neben dem generischen Error-Konstruktor gibt es weitere zentrale Fehler-Konstruktoren in JavaScript.

EvalError — Erstellt eine Instanz, die einen Fehler in Bezug auf die globale Funktion eval() darstellt.
RangeError — Erstellt eine Instanz, die einen Fehler darstellt, wenn eine numerische Variable oder ein Parameter außerhalb ihres gültigen Bereichs liegt.
ReferenceError — Erstellt eine Instanz, die einen Fehler beim Dereferenzieren einer ungültigen Referenz darstellt.
SyntaxError — Erstellt eine Instanz, die einen Syntaxfehler darstellt.
TypeError — Erstellt eine Instanz, die einen Fehler darstellt, wenn eine Variable oder ein Parameter nicht von einem gültigen Typ ist.
URIError — Erstellt eine Instanz, die einen Fehler darstellt, wenn encodeURI() oder decodeURI() ungültige Parameter übergeben werden.
AggregateError — Erstellt eine Instanz, die mehrere in einem einzigen Fehler zusammengefasste Fehler darstellt, wenn eine Operation mehrere Fehler melden muss, zum Beispiel Promise.any().
InternalError (nicht standardisiert) — Erstellt eine Instanz, die einen Fehler darstellt, wenn ein interner Fehler in der JavaScript-Engine geworfen wird. Z. B. „too much recursion".

Parameter

Name	Typ	Default	Beschreibung
$message	string	""	Eine menschenlesbare Beschreibung des Fehlers. Wird als `error.message` gespeichert.
$options	object		Ein optionales Konfigurationsobjekt. Die Eigenschaft `cause` (beliebiger Wert) erlaubt es, die ursprüngliche Fehlerursache zu ketten (seit ES2022).

Rückgabewert

Typ

Error

Beschreibung

Eine neue Error-Instanz mit den Eigenschaften name, message, stack und ggf. cause.

Beispiele

Werfen eines generischen Fehlers

try {
  throw new Error("Whoops!");
} catch (e) {
  console.error(`${e.name}: ${e.message}`);
}

Behandeln eines bestimmten Fehlertyps

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;
  }
}

Unterscheiden zwischen ähnlichen Fehlern

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;
  }
}

cause in einer Unterklasse weiterreichen

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

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
}

// Wichtig · Fallstricke

Hinweis: Wenn du eine Bibliothek entwickelst, solltest du bevorzugt die error cause verwenden, um zwischen verschiedenen ausgegebenen Fehlern zu unterscheiden — anstatt deine Konsumenten dazu zu bringen, die Fehlermeldung zu parsen. Warnung: Das Ableiten von eingebauten Klassen kann nicht zuverlässig auf pre-ES6-Code transpiliert werden, da es keine Möglichkeit gibt, die Basisklasse mit einem bestimmten new.target ohne Reflect.construct() zu konstruieren. Du benötigst zusätzliche Konfiguration oder musst am Ende des Konstruktors manuell Object.setPrototypeOf(this, CustomError.prototype) aufrufen; andernfalls ist die konstruierte Instanz keine CustomError-Instanz. Hinweis: Einige Browser schließen den CustomError-Konstruktor in den Stack-Trace ein, wenn ES2015-Klassen verwendet werden.

Siehe auch

EvalError RangeError ReferenceError SyntaxError TypeError URIError AggregateError