throw

throw expression;

expression

Der Ausdruck, der ausgelöst werden soll.

Die throw-Anweisung ist in allen Kontexten gültig, in denen Anweisungen verwendet werden können. Ihre Ausführung erzeugt eine Ausnahme, die durch den Aufrufstapel durchdringt. Für weitere Informationen über Fehlerweitergabe und -behandlung siehe Ablaufsteuerung und Fehlerbehandlung.

Das throw-Schlüsselwort kann von jedem Ausdruck gefolgt werden, zum Beispiel:

throw error; // Throws a previously defined value (e.g. within a catch block)
throw new Error("Required"); // Throws a new Error object

In der Praxis sollte die Ausnahme, die Sie auslösen, immer ein Error-Objekt oder eine Instanz einer Error-Unterklasse, wie zum Beispiel RangeError, sein. Der Grund ist, dass der Code, der den Fehler auffängt, möglicherweise bestimmte Eigenschaften, wie message, auf dem aufgefangenen Wert erwartet. Zum Beispiel werfen Web-APIs typischerweise DOMException-Instanzen, die von Error.prototype erben.

Die Syntax verbietet Zeilenendzeichen zwischen dem throw-Schlüsselwort und dem Ausdruck, der geworfen werden soll.

throw
new Error();

Der obige Code wird durch automatische Semikolon-Einfügung (ASI) in:

throw;
new Error();

umgewandelt. Dies ist ungültiger Code, denn im Gegensatz zu return muss throw von einem Ausdruck gefolgt werden.

Um dieses Problem zu vermeiden (um ASI zu verhindern), könnten Sie Klammern verwenden:

throw (
  new Error()
);

Dieses Beispiel definiert eine Funktion, die einen TypeError wirft, wenn der Eingabewert nicht vom erwarteten Typ ist.

function isNumeric(x) {
  return ["number", "bigint"].includes(typeof x);
}

function sum(...values) {
  if (!values.every(isNumeric)) {
    throw new TypeError("Can only add numbers");
  }
  return values.reduce((a, b) => a + b);
}

console.log(sum(1, 2, 3)); // 6
try {
  sum("1", "2");
} catch (e) {
  console.error(e); // TypeError: Can only add numbers
}

Dieses Beispiel ruft eine Callback-basierte asynchrone Funktion auf und wirft einen Fehler, wenn der Callback einen Fehler erhält.

readFile("foo.txt", (err, data) => {
  if (err) {
    throw err;
  }
  console.log(data);
});

Fehler, die auf diese Weise geworfen werden, können vom Aufrufer nicht aufgefangen werden und führen zum Absturz des Programms, es sei denn, (a) die readFile-Funktion fängt den Fehler selbst ab, oder (b) das Programm läuft in einem Kontext, der Top-Level-Fehler abfängt. Sie können Fehler natürlicher handhaben, indem Sie den Promise()-Konstruktor verwenden.

function readFilePromise(path) {
  return new Promise((resolve, reject) => {
    readFile(path, (err, data) => {
      if (err) {
        reject(err);
      }
      resolve(data);
    });
  });
}

try {
  const data = await readFilePromise("foo.txt");
  console.log(data);
} catch (err) {
  console.error(err);
}

• try...catch
• Error