Hướng dẫn how do you create a new error in javascript? - làm thế nào để bạn tạo một lỗi mới trong javascript?

Cú pháp

new Error[]
new Error[message]
new Error[message, options]
new Error[message, fileName]
new Error[message, fileName, lineNumber]

Error[]
Error[message]
Error[message, options]
Error[message, fileName]
Error[message, fileName, lineNumber]

Lưu ý: Error[] có thể được gọi có hoặc không có

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

Thông số

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

Một mô tả có thể đọc được của con người về lỗi.

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

Một đối tượng có các thuộc tính sau:

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

Một thuộc tính chỉ ra nguyên nhân cụ thể của lỗi. Khi bắt và ném lại lỗi với thông báo lỗi cụ thể hoặc hữu ích hơn, thuộc tính này có thể được sử dụng để truyền lỗi ban đầu.

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

Giá trị cho thuộc tính

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

Giá trị cho thuộc tính

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

Ví dụ

Gọi chức năng hoặc xây dựng mới

Khi

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

Phát triển lại một lỗi với một nguyên nhân

Đôi khi rất hữu ích để bắt một lỗi và ném lại nó bằng một thông báo mới. Trong trường hợp này, bạn nên chuyển lỗi ban đầu vào hàm tạo cho

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

try {
  frameworkThatCanThrow[];
} catch [err] {
  throw new Error["New error message", { cause: err }];
}

Để biết ví dụ chi tiết hơn, hãy xem Lỗi> Phân biệt giữa các lỗi tương tự.

Xem thêm

• Một polyfill của

  const x = Error["I was created using a function call!"];
  
  // above has the same functionality as following
  const y = new Error['I was constructed via the "new" keyword!'];
  

  1 với hành vi hiện đại như hỗ trợ

  const x = Error["I was created using a function call!"];
  
  // above has the same functionality as following
  const y = new Error['I was constructed via the "new" keyword!'];
  

  4 có sẵn trong

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

  2

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

  3

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

  4
• Nguyên nhân lỗi [v8.dev/eatures]

Sự mô tả

Lỗi thời gian chạy dẫn đến các đối tượng

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

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

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

Loại lỗi

Bên cạnh hàm tạo

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

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

Tạo một thể hiện biểu thị một lỗi xảy ra liên quan đến hàm toàn cầu

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

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

Tạo một thể hiện biểu thị một lỗi xảy ra khi một biến hoặc tham số số nằm ngoài phạm vi hợp lệ của nó.

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

Tạo một thể hiện biểu thị một lỗi xảy ra khi không tham chiếu tham chiếu không hợp lệ.

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

Tạo một thể hiện đại diện cho một lỗi cú pháp.

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

Tạo một thể hiện biểu thị một lỗi xảy ra khi một biến hoặc tham số không thuộc loại hợp lệ.

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

Tạo một thể hiện biểu thị một lỗi xảy ra khi

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

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

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

Tạo một thể hiện đại diện cho một số lỗi được bọc trong một lỗi duy nhất khi cần có nhiều lỗi được báo cáo bởi một thao tác, ví dụ như

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

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

Tạo một thể hiện biểu thị một lỗi xảy ra khi lỗi bên trong trong công cụ JavaScript bị ném. Ví dụ. "Quá nhiều đệ quy".

Người xây dựng

Error[]

Tạo một đối tượng

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

Phương pháp tĩnh

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

Hàm V8 không chuẩn tạo thuộc tính

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

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

Một thuộc tính số V8 không chuẩn, giới hạn số lượng khung ngăn xếp trong một stacktrace lỗi.

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

Chức năng V8 không chuẩn, nếu được cung cấp bởi UserCode, được gọi bởi động cơ JavaScript V8 cho các ngoại lệ ném, cho phép người dùng cung cấp định dạng tùy chỉnh cho các ngăn xếp.

Thuộc tính thể hiện

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

Thông báo lỗi. Đối với các đối tượng

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

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

Tên lỗi. Điều này được xác định bởi hàm tạo hàm.

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

Lỗi nguyên nhân chỉ ra lý do tại sao lỗi hiện tại được ném - thường là một lỗi bị bắt khác. Đối với các đối tượng

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

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

Một thuộc tính Mozilla không chuẩn cho đường dẫn đến tệp đã nêu ra lỗi này.

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

Một thuộc tính Mozilla không chuẩn cho số dòng trong tệp đã nêu lỗi này.

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

Một thuộc tính Mozilla không chuẩn cho số cột trong dòng đã nêu ra lỗi này.

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

Một tài sản không chuẩn cho một dấu vết ngăn xếp.

Phương pháp thể hiện

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 [only available on V8]
    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]; // stacktrace
}

Trả về một chuỗi đại diện cho đối tượng được chỉ định. Ghi đè phương thức

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 [only available on V8]
    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]; // stacktrace
}

Ví dụ

Ném một lỗi chung

Thông thường bạn tạo một đối tượng

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

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

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

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

Xử lý một loại lỗi cụ thể

Bạn có thể chọn chỉ xử lý các loại lỗi cụ thể bằng cách kiểm tra loại lỗi với thuộc tính

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 [only available on V8]
    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]; // stacktrace
}

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 [only available on V8]
    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]; // stacktrace
}

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

Phân biệt giữa các lỗi tương tự

Đôi khi, một khối mã có thể thất bại vì những lý do yêu cầu xử lý khác nhau, nhưng ném các lỗi rất giống nhau [nghĩa là với cùng loại và thông báo].

Nếu bạn không có quyền kiểm soát các lỗi ban đầu được ném, một tùy chọn là bắt chúng và ném các đối tượng

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

Ví dụ dưới đây cho thấy điều này cho hai phương pháp sẽ thất bại với các lỗi tương tự [Error[]1 và Error[]2]:

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

Lưu ý: Nếu bạn đang tạo thư viện, bạn nên sử dụng lỗi gây ra lỗi để phân biệt giữa các lỗi khác nhau - thay vì yêu cầu người tiêu dùng của bạn phân tích thông báo lỗi. Xem trang Nguyên nhân lỗi cho một ví dụ. If you are making a library, you should prefer to use error cause to discriminate between different errors emitted — rather than asking your consumers to parse the error message. See the error cause page for an example.

Các loại lỗi tùy chỉnh cũng có thể sử dụng thuộc tính

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

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

Các loại lỗi tùy chỉnh

Bạn có thể muốn xác định các loại lỗi của riêng mình xuất phát từ

const x = Error["I was created using a function call!"];

// above has the same functionality as following
const y = new Error['I was constructed via the "new" keyword!'];

Xem "Cách tốt để gia hạn lỗi trong JavaScript là gì?" trên stackoverflow cho một cuộc thảo luận chuyên sâu.

Lưu ý: Một số trình duyệt bao gồm hàm tạo Error[]2 trong dấu vết ngăn xếp khi sử dụng các lớp ES2015. Some browsers include the Error[]2 constructor in the stack trace when using ES2015 classes.

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 [only available on V8]
    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]; // stacktrace
}

Xem thêm

• Một polyfill của

  const x = Error["I was created using a function call!"];
  
  // above has the same functionality as following
  const y = new Error['I was constructed via the "new" keyword!'];
  

  1 với hành vi hiện đại như hỗ trợ

  const x = Error["I was created using a function call!"];
  
  // above has the same functionality as following
  const y = new Error['I was constructed via the "new" keyword!'];
  

  4 có sẵn trong

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

  2

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

  3

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

  4
• Tài liệu V8 cho

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

  6,

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

  8 và

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

  9.