Javascript自定义错误，继承Error

Javascript自定义错误，继承Error

在开发过程中，经常需要我们自己的错误类，用于描述任务中可能发生错误的特别内容。如网络操作错误，可能需要HttpError,数据库操作错误DbError以及搜索操作错误NotFoundError等等。

我们的错误应该支持基本的错误属性，如：message,name以及更详细的stack，也可能有其他属性，如HttpError对象可能有statusCode属性，如：404、403、500。

Javascript使用throw可以带任何参数，所以技术上自定义错误不需要继承Error,但通过继承，可以使用obj instanceof Error去区别错误对象，所以最好使用继承。

当我们搭建应用时，我们的错误自然形成层次结构，举例，HttpTimeoutError可能继承自HttpError等。

扩展Error

举例，我们考虑函数readUser(json)可以读取用户数据，下面是一个有效的json数据。

let json = `{ "name": "John", "age": 30 }`;

我们自然使用JSON.parse，如果接收到畸形的json，则会抛出SyntaxError错误。

即使json是语法正确的，也不意味是有有效的user，对吗？可以丢失有效的数据，举例，如果没有基本的name和age属性。

函数readUser(json)应该不仅读json，也应该检查（验证）数据。如果没有必须的属性或格式错误，则为错误，这不属于SyntaxError，因为数据语法正确，而是另一种类型错误，我们称为ValidationError，需要为之创建类，其也应该能承载缺失字段信息。

我们的ValidationError类应该继承自内置的Error类：

该类是内置的，但是在我们眼里应该大致的代码，来理解我们在扩展什么。代码如下：

// The "pseudocode" for the built-in Error class defined by JavaScript itself
class Error {
  constructor(message) {
    this.message = message;
    this.name = "Error"; // (different names for different built-in error classes)
    this.stack = <nested calls>; // non-standard, but most environments support it
  }
}

现在，让我们继续并从它继承类ValidationError：

class ValidationError extends Error {
  constructor(message) {
    super(message); // (1)
    this.name = "ValidationError"; // (2)
  }
}

function test() {
  throw new ValidationError("Whoops!");
}

try {
  test();
} catch(err) {
  alert(err.message); // Whoops!
  alert(err.name); // ValidationError
  alert(err.stack); // a list of nested calls with line numbers for each
}

请看构造函数：

1. 行(1)我们调用父类构造函数，Javascript需要我们在子类构造函数中调用super，这时强制的。父类构造函数设置message属性。
2. 父类构造函数也设置name属性为Error，所以行(2)我们重置为正确的值。

现在尝试在readUser(json)中使用。

class ValidationError extends Error {
  constructor(message) {
    super(message);
    this.name = "ValidationError";
  }
}

// Usage
function readUser(json) {
  let user = JSON.parse(json);

  if (!user.age) {
    throw new ValidationError("No field: age");
  }
  if (!user.name) {
    throw new ValidationError("No field: name");
  }

  return user;
}

// Working example with try..catch

try {
  let user = readUser('{ "age": 25 }');
} catch (err) {
  if (err instanceof ValidationError) {
    alert("Invalid data: " + err.message); // Invalid data: No field: name
  } else if (err instanceof SyntaxError) { // (*)
    alert("JSON Syntax Error: " + err.message);
  } else {
    throw err; // unknown error, rethrow it (**)
  }
}

代码块try...catch处理ValidationError错误和内置的SyntaxError。

请看星号行，我们使用instanceof检查特定的错误类型，我们也可以看到err.name方式，如下：

// ...
// instead of (err instanceof SyntaxError)
} else if (err.name == "SyntaxError") { // (*)
// ...

使用instanceof方式更好，因为未来可以可能会继续扩展ValidationError创建子类，如PropertyRequiredError.instanceof方式对新继承类仍正常工作，所以不会过时。

这也很重要，如果catch块中遇到未知错误，那么会重新抛出错误（在**行），catch块仅知道如何处理验证和语法错误，其他错误应该不捕获。

进一步继承

类ValidationError很通过，很多情况可能会误解，属性缺失或格式错误（age值为字符串）。让我们创建更具体类PropertyRequiredError，针对属性缺失错误，包括具体那个属性缺失的额外信息。

class ValidationError extends Error {
  constructor(message) {
    super(message);
    this.name = "ValidationError";
  }
}

class PropertyRequiredError extends ValidationError {
  constructor(property) {
    super("No property: " + property);
    this.name = "PropertyRequiredError";
    this.property = property;
  }
}

// Usage
function readUser(json) {
  let user = JSON.parse(json);

  if (!user.age) {
    throw new PropertyRequiredError("age");
  }
  if (!user.name) {
    throw new PropertyRequiredError("name");
  }

  return user;
}

// Working example with try..catch

try {
  let user = readUser('{ "age": 25 }');
} catch (err) {
  if (err instanceof ValidationError) {
    alert("Invalid data: " + err.message); // Invalid data: No property: name
    alert(err.name); // PropertyRequiredError
    alert(err.property); // name
  } else if (err instanceof SyntaxError) {
    alert("JSON Syntax Error: " + err.message);
  } else {
    throw err; // unknown error, rethrow it
  }
}

新的类PropertyRequiredError也容易使用：仅需要传递属性名称：new PropertyRequiredError(property)。构造函数生成人类易懂的message属性值。

请注意在PropertyRequiredError构造函数再次手工给this.name赋值。这可能有点冗长，创建每个自定义错误都需要赋值：this.name = <class name>，但有其他方法，我们创建我们自己的基础错误类，通过赋值this.constructor.name 给 this.name，然后再从该类继承会简化。

我们称之为：MyError.

下面是MyError及其他自定义类的代码：

class MyError extends Error {
  constructor(message) {
    super(message);
    this.name = this.constructor.name;
  }
}

class ValidationError extends MyError { }

class PropertyRequiredError extends ValidationError {
  constructor(property) {
    super("No property: " + property);
    this.property = property;
  }
}

// name is correct
alert( new PropertyRequiredError("field").name ); // PropertyRequiredError

现在自定义错误相当简短，特别是ValidationError, 因为构造行数中删除了该行："this.name = ...".

包装异常

上面代码中的readUser函数的目的是读取用户数据，对吗？在处理的过程中有可能有其他错误发生。现在我们有了SyntaxError和ValidationError，但未来，readUser函数可能会扩展:新代码可能会生成其他类型的错误。

调用readUser函数的代码应该处理这些错误，现在catch块使用多个if检查不同类型的错误，然后重新抛出未知促我。但如果readUser函数产生几种不同类型的错误——那么我们要问自己，真的想通过一个一个检查所有的错误吗？

答案当然是“No”：外部代码想要“高于一切”的抽象错误类，如“数据读错误”。通常其错误描述信息不准确，或者，如果有一种获取错误细节的方法，那就更好了，但仅为如果需要时。

所以让我们创建一个ReadError来表现这些错误，如果在readUser内部发生错误，我们捕获并生成ReadError错误。同时保留原始错误的引用至cause属性。那么外部代码仅需要检查ReadError。

下面代码定义ReadError并演示在try...catch块中使用readUser。

class ReadError extends Error {
  constructor(message, cause) {
    super(message);
    this.cause = cause;
    this.name = 'ReadError';
  }
}

class ValidationError extends Error { /*...*/ }
class PropertyRequiredError extends ValidationError { /* ... */ }

function validateUser(user) {
  if (!user.age) {
    throw new PropertyRequiredError("age");
  }

  if (!user.name) {
    throw new PropertyRequiredError("name");
  }
}

function readUser(json) {
  let user;

  try {
    user = JSON.parse(json);
  } catch (err) {
    if (err instanceof SyntaxError) {
      throw new ReadError("Syntax Error", err);
    } else {
      throw err;
    }
  }

  try {
    validateUser(user);
  } catch (err) {
    if (err instanceof ValidationError) {
      throw new ReadError("Validation Error", err);
    } else {
      throw err;
    }
  }

}

try {
  readUser('{bad json}');
} catch (e) {
  if (e instanceof ReadError) {
    alert(e);
    // Original error: SyntaxError: Unexpected token b in JSON at position 1
    alert("Original error: " + e.cause);
  } else {
    throw e;
  }
}

上面代码中，readUser如描述的一样工作正常——捕获syntax和validation错误，然后抛出ReadError错误，代替之前的未知错误重新抛出。

所以外部代码检查instanceof ReadError，无需列出所有类型的错误。

这种方法称为“包装异常”，因为我们获得“低级别的异常”并包装至ReadError，对调用代码来说，更抽象更方便。在面向对象编程中广泛使用。

总结

• 通常可以从Error或其他的内置错误类中继承，只需关心name属性，不要忘记调用super。
• 大多数时，应该使用instanceof检查特定错误，也支持继承类。但有时有错误对象来自第三方库，不容易获得其类，那么name属性可以被使用。
• 包装异常被普遍使用，当函数处理低级别异常，并使一个更高级别的对象报告错误，低级别异常有时编程对象属性，如上面示例中的err.cause，但没有严格规定。