Error 对象的自定义扩展与错误链（Error Cause）处理

好的，各位观众老爷们，今天咱们来聊点有意思的：Error 对象的自定义扩展和错误链（Error Cause）的处理。听起来是不是有点高大上？别怕，咱用人话讲，保证你听完之后醍醐灌顶，感觉自己瞬间从青铜升到王者！

开场白：Error，你这个磨人的小妖精！

话说这编程的世界，风光无限好，但总有那么几个“磨人的小妖精”时不时跳出来捣乱，它们就是——Error（错误）！ 🐛

Error就像生活中的小插曲，时不时给你来个“惊喜”。代码跑得好好的，突然“啪”一下，给你弹个错误，轻则程序崩溃，重则数据丢失，让你捶胸顿足，恨不得把电脑砸了。

但别急，Error虽然讨厌，但也是我们程序猿的好朋友。它们就像代码的“体检报告”，告诉我们哪里出了问题，让我们有机会亡羊补牢，把代码写得更健壮。

第一幕：Error 对象，不只是个“报错信息”！

我们先来认识一下 Error 对象。在 JavaScript (或其他编程语言) 中，Error 对象可不是一个简单的“报错信息”，它其实是一个“有故事”的对象。

try {
  // 可能会出错的代码
  throw new Error("哎呀，出错啦！");
} catch (error) {
  console.log(error.name);   // "Error"
  console.log(error.message); // "哎呀，出错啦！"
  console.log(error.stack);   // 错误堆栈信息，追踪错误来源
}

name: 错误类型的名称，比如 "Error", "TypeError", "ReferenceError" 等。
message: 错误的描述信息，也就是我们看到的报错内容。
stack: 错误堆栈信息，告诉我们错误发生的调用链，方便我们追踪错误的根源。

但是，原生的 Error 对象提供的信息有时候不够用。比如，我们想知道错误发生的具体位置（文件名、行号），或者想给错误对象添加一些自定义的属性，怎么办呢？这就引出了我们今天的主题：Error 对象的自定义扩展！

第二幕：Error 对象的自定义扩展，让错误信息更“有料”！

自定义扩展 Error 对象，就像给 Error 对象穿上定制的“战袍”，让它在战场上更加威风凛凛，提供更多有用的信息。

方法一：继承 Error 对象

这是最常见，也是最正统的方法。我们可以创建一个新的类，继承自 Error 对象，并在新类中添加我们需要的属性和方法。

class ValidationError extends Error {
  constructor(message, field) {
    super(message); // 调用父类的 constructor，设置 message 属性
    this.name = "ValidationError"; // 自定义错误名称
    this.field = field;           // 自定义属性，表示出错的字段
  }
}

function validateAge(age) {
  if (age < 0 || age > 150) {
    throw new ValidationError("年龄不合法", "age");
  }
}

try {
  validateAge(-10);
} catch (error) {
  if (error instanceof ValidationError) {
    console.log(error.name);    // "ValidationError"
    console.log(error.message); // "年龄不合法"
    console.log(error.field);   // "age"
  }
}

代码解析：
- 我们创建了一个 ValidationError 类，继承自 Error 类。
- 在 constructor 中，我们调用了 super(message) 来初始化父类的 message 属性。
- 我们还自定义了 name 属性，设置为 "ValidationError"，方便我们区分错误类型。
- 最重要的是，我们添加了 field 属性，表示出错的字段。
优点：
- 类型安全：使用 instanceof 可以准确判断错误类型。
- 代码可读性高：自定义的错误类型更容易理解。
缺点：
- 代码量稍多：需要定义一个新的类。

方法二：直接修改 Error 对象

如果你觉得定义一个新的类太麻烦，也可以直接修改 Error 对象，给它添加自定义属性。

try {
  throw new Error("文件不存在");
} catch (error) {
  error.code = "FILE_NOT_FOUND"; // 添加自定义属性
  error.path = "/path/to/file";   // 添加自定义属性
  console.log(error.message); // "文件不存在"
  console.log(error.code);    // "FILE_NOT_FOUND"
  console.log(error.path);    // "/path/to/file"
}

代码解析：
- 我们在 catch 块中，直接给 error 对象添加了 code 和 path 属性。
优点：
- 代码简洁：不需要定义新的类。
缺点：
- 类型不安全：无法使用 instanceof 判断错误类型。
- 代码可读性稍差：可能会让别人觉得你“不按套路出牌”。

方法三：使用 Error.prototype

如果你想给所有的 Error 对象都添加某个属性或方法，可以使用 Error.prototype。

Error.prototype.toJSON = function() {
  return {
    name: this.name,
    message: this.message,
    stack: this.stack,
    // ... 其他自定义属性
  };
};

try {
  throw new Error("服务器错误");
} catch (error) {
  console.log(JSON.stringify(error)); // 将 Error 对象转换为 JSON 字符串
}

代码解析：
- 我们给 Error.prototype 添加了一个 toJSON 方法，用于将 Error 对象转换为 JSON 字符串。
优点：
- 方便：可以给所有的 Error 对象添加统一的行为。
缺点：
- 可能会污染全局的 Error 对象，不建议滥用。

总结：Error 对象自定义扩展的方法对比

方法	优点	缺点	适用场景
继承 Error 对象	类型安全，代码可读性高	代码量稍多	需要明确错误类型，代码需要高可读性
直接修改 Error 对象	代码简洁	类型不安全，代码可读性稍差	只需要添加少量属性，对类型要求不高
使用 Error.prototype	方便，可以给所有 Error 对象添加统一行为	可能会污染全局 Error 对象，不建议滥用	需要给所有 Error 对象添加统一行为，谨慎使用

第三幕：错误链（Error Cause），追根溯源，一网打尽！

现在我们已经知道如何自定义 Error 对象了，接下来我们来聊聊错误链（Error Cause）。

错误链就像一个“追溯系统”，可以让我们追溯错误的根源。想象一下，你调用了一个函数，这个函数又调用了另一个函数，最终在最底层的函数中发生了错误。如果我们只知道最外层函数报错了，很难找到错误的根源。

错误链就像一条线，把这些错误串起来，让我们能够从最外层的错误，一直追溯到最底层的错误，最终找到问题的根源。

Error Cause 的标准

目前，JavaScript 还没有 Error Cause 的官方标准。但是，有一个提案正在制定中，它建议给 Error 对象添加一个 cause 属性，用于表示错误的根本原因。

try {
  // 可能会出错的代码
  JSON.parse("invalid json");
} catch (error) {
  throw new Error("解析 JSON 失败", { cause: error });
}

代码解析：
- 我们在 catch 块中，创建了一个新的 Error 对象，并将原始的 error 对象作为 cause 属性的值。
优点：
- 可以清晰地表示错误的根本原因。
- 方便我们追溯错误的来源。

如何使用 Error Cause

async function loadData(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    return await response.json();
  } catch (error) {
    throw new Error(`Failed to load data from ${url}`, { cause: error });
  }
}

async function processData(url) {
  try {
    const data = await loadData(url);
    // ... 处理数据的代码
  } catch (error) {
    console.error("Error processing data:", error);
    console.error("Cause:", error.cause); // 打印错误的根本原因
  }
}

processData("https://example.com/data.json");

代码解析：
- 在 loadData 函数中，如果 fetch 请求失败，我们会抛出一个新的 Error 对象，并将原始的 error 对象作为 cause 属性的值。
- 在 processData 函数中，我们捕获了 loadData 函数抛出的错误，并打印了错误的根本原因。

Error Cause 的兼容性

由于 Error Cause 还是一个提案，目前并不是所有的浏览器和 Node.js 环境都支持它。如果你想使用 Error Cause，可以使用一些 polyfill 或库，比如 error-cause。

第四幕：错误处理的最佳实践，让你的代码更健壮！ 💪

最后，我们来聊聊错误处理的最佳实践，让你的代码更加健壮，避免“一错全崩”的惨剧。

尽早发现错误： 在代码编写阶段，就要考虑到可能出现的错误，并进行相应的处理。
使用 try…catch 块： 将可能出错的代码放在 try 块中，并在 catch 块中捕获错误。
不要忽略错误： 捕获到错误后，不要只是简单地 console.log 一下，而是要进行适当的处理，比如重试、回滚、记录日志等。
抛出有意义的错误： 抛出错误时，要提供足够的信息，方便我们定位问题。
使用错误链： 使用 Error Cause 可以清晰地表示错误的根本原因，方便我们追溯错误的来源。
编写单元测试： 编写单元测试可以帮助我们发现代码中的错误，并确保代码的健壮性。
记录日志： 将错误信息记录到日志中，方便我们分析问题。

总结：

Error 对象自定义扩展和错误链（Error Cause）是提高代码健壮性的重要手段。通过自定义 Error 对象，我们可以提供更丰富的错误信息。通过使用错误链，我们可以追溯错误的根源。掌握这些技巧，可以让我们更好地处理错误，提高代码的质量。

结尾：和 Error 做朋友，让代码更美好！ 🎉

好了，今天的分享就到这里。希望大家能够记住，Error 并不可怕，只要我们掌握了正确的方法，就可以和 Error 做朋友，让我们的代码更加美好！记住，每一次的错误，都是一次成长的机会！祝大家编程愉快，Bug 越来越少！ 😉

发表回复 取消回复

发表回复取消回复