throw

BaselineWidely available

This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.

Thethrow statement throws a user-defined exception. Execution of the current function will stop (the statements afterthrow won't be executed), and control will be passed to the firstcatch block in the call stack. If nocatch block exists among caller functions, the program will terminate.

Try it

function getRectArea(width, height) {  if (isNaN(width) || isNaN(height)) {    throw new Error("Parameter is not a number!");  }}try {  getRectArea(3, "A");} catch (e) {  console.error(e);  // Expected output: Error: Parameter is not a number!}

Syntax

throw expression;

expression: The expression to throw.

Description

Thethrow statement is valid in all contexts where statements can be used. Its execution generates an exception that penetrates through the call stack. For more information on error bubbling and handling, seeControl flow and error handling.

Thethrow keyword can be followed by any kind of expression, for example:

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

In practice, the exception you throw shouldalways be anError object or an instance of anError subclass, such asRangeError. This is because code that catches the error may expect certain properties, such asmessage, to be present on the caught value. For example, web APIs typically throwDOMException instances, which inherit fromError.prototype.

Automatic semicolon insertion

The syntax forbids line terminators between thethrow keyword and the expression to be thrown.

thrownew Error();

The code above is transformed byautomatic semicolon insertion (ASI) into:

throw;new Error();

This is invalid code, because unlikereturn,throw must be followed by an expression.

To avoid this problem (to prevent ASI), you could use parentheses:

throw (  new Error());

Examples

Throwing a user-defined error

This example defines a function that throws aTypeError if the input is not of the expected type.

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)); // 6try {  sum("1", "2");} catch (e) {  console.error(e); // TypeError: Can only add numbers}

Throwing an existing object

This example calls a callback-based async function, and throws an error if the callback receives an error.

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

Errors thrown this way are not catchable by the caller and will cause the program to crash unless (a) thereadFile function itself catches the error, or (b) the program is running in a context that catches top-level errors. You can handle errors more naturally by using thePromise() constructor.

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