Error

Mô tả

Các lỗi runtime dẫn đến việc tạo và ném ra các đối tượng Error mới.

Error là một serializable object, vì vậy nó có thể được nhân bản với structuredClone() hoặc sao chép giữa các Worker bằng cách sử dụng postMessage().

Các loại Error

Bên cạnh constructor Error chung, có các constructor lỗi cốt lõi khác trong JavaScript. Để biết về các ngoại lệ phía client, xem Các câu lệnh xử lý ngoại lệ.

EvalError

Tạo một instance đại diện cho lỗi xảy ra liên quan đến hàm toàn cục eval().

RangeError

Tạo một instance đại diện cho 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ó.

ReferenceError

Tạo một instance đại diện cho lỗi xảy ra khi hủy tham chiếu một tham chiếu không hợp lệ.

SyntaxError

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

TypeError

Tạo một instance đại diện cho lỗi xảy ra khi một biến hoặc tham số không thuộc kiểu hợp lệ.

URIError

Tạo một instance đại diện cho lỗi xảy ra khi encodeURI() hoặc decodeURI() được truyền tham số không hợp lệ.

AggregateError

Tạo một instance đại diện cho nhiều lỗi được gói trong một lỗi duy nhất khi nhiều lỗi cần được báo cáo bởi một thao tác, ví dụ bởi Promise.any().

InternalError Non-standard

Tạo một instance đại diện cho lỗi xảy ra khi một lỗi nội bộ trong JavaScript engine được ném ra. Ví dụ: "too much recursion".

Constructor

Error()

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

Thuộc tính tĩnh

Error.stackTraceLimit Non-standard

Thuộc tính số không chuẩn giới hạn số lượng stack frame được bao gồm trong stack trace của lỗi.

Phương thức tĩnh

Error.captureStackTrace()

Hàm không chuẩn tạo thuộc tính stack trên đối tượng được cung cấp.

Error.isError()

Trả về true nếu đối số là một lỗi, hoặc false trong trường hợp ngược lại.

Error.prepareStackTrace() Non-standard Optional

Hàm không chuẩn mà nếu được cung cấp bởi code người dùng, sẽ được JavaScript engine gọi cho các ngoại lệ được ném ra, cho phép người dùng cung cấp định dạng tùy chỉnh cho stack trace. Xem tài liệu V8 Stack Trace API.

Thuộc tính instance

Các thuộc tính này được định nghĩa trên Error.prototype và được chia sẻ bởi tất cả các instance Error.

Error.prototype.constructor

Hàm constructor đã tạo ra đối tượng instance. Đối với các instance Error, giá trị khởi tạo là constructor Error.

Error.prototype.name

Đại diện cho tên của loại lỗi. Đối với Error.prototype.name, giá trị khởi tạo là "Error". Các lớp con như TypeError và SyntaxError cung cấp các thuộc tính name riêng của chúng.

Error.prototype.stack Non-standard

Thuộc tính không chuẩn cho một stack trace.

Các thuộc tính này là thuộc tính riêng của mỗi instance Error.

cause

Nguyên nhân lỗi chỉ ra lý do tại sao lỗi hiện tại được ném ra — thường là một lỗi khác đã bắt được. Đối với các đối tượng Error do người dùng tạo, đây là giá trị được cung cấp làm thuộc tính cause của đối số thứ hai của constructor.

columnNumber Non-standard

Thuộc tính Mozilla không chuẩn cho số cột trong dòng đã gây ra lỗi này.

fileName Non-standard

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

lineNumber Non-standard

Thuộc tính Mozilla không chuẩn cho số dòng trong tệp đã gây ra lỗi này.

message

Thông báo lỗi. Đối với các đối tượng Error do người dùng tạo, đây là chuỗi được cung cấp làm đối số đầu tiên của constructor.

Phương thức instance

Error.prototype.toString()

Trả về chuỗi biểu diễn đối tượng được chỉ định. Ghi đè phương thức Object.prototype.toString().

Ví dụ

Ném một lỗi chung

Thông thường bạn tạo đối tượng Error với ý định ném nó bằng từ khóa throw. Bạn có thể xử lý lỗi bằng cấu trúc try...catch:

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 từ khóa instanceof:

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 code có thể thất bại vì những lý do đòi hỏi cách xử lý khác nhau, nhưng lại ném ra các lỗi rất giống nhau (tức là, cùng loại và thông báo).

Nếu bạn không kiểm soát được các lỗi gốc được ném ra, một lựa chọn là bắt chúng và ném các đối tượng Error mới có thông báo cụ thể hơn. Lỗi gốc nên được truyền đến Error mới trong tham số options của constructor dưới dạng thuộc tính cause. Điều này đảm bảo rằng lỗi gốc và stack trace có sẵn cho các khối try/catch cấp cao hơn.

Ví dụ dưới đây minh họa điều này cho hai phương thức mà nếu không sẽ thất bại với các lỗi tương tự (doFailSomeWay() và doFailAnotherWay()):

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

Các loại error tùy chỉnh cũng có thể sử dụng thuộc tính cause, với điều kiện constructor của lớp con truyền tham số options khi gọi super(). Constructor lớp cơ sở Error() sẽ đọc options.cause và định nghĩa thuộc tính cause trên instance lỗi mới.

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 error tùy chỉnh

Bạn có thể muốn định nghĩa các loại lỗi của riêng mình được dẫn xuất từ Error để có thể throw new MyError() và sử dụng instanceof MyError để kiểm tra loại lỗi trong exception handler. Điều này giúp code xử lý lỗi gọn gàng và nhất quán hơn.

Xem "What's a good way to extend Error in JavaScript?" trên Stack Overflow để có thảo luận chuyên sâu.

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
}

Đặc tả kỹ thuật

Tương thích trình duyệt

Xem thêm

• Polyfill của Error với hỗ trợ cause trong core-js
• Polyfill es-shims của Error cause
• throw
• try...catch
• Stack trace API trong tài liệu V8