在开发过程中,经常需要我们自己的错误类,用于描述任务中可能发生错误的特别内容。如网络操作错误,可能需要
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)我们调用父类构造函数,Javascript需要我们在子类构造函数中调用super,这时强制的。父类构造函数设置message属性。
- 父类构造函数也设置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
,但没有严格规定。
文章出处:https://blog.csdn.net/neweastsun/article/details/76371061