vipxieliang头像

JavaScript 错误处理最佳实践:从 Error 类型到全局兜底

1. 引言

错误处理是 JavaScript 工程里最容易被忽视、却最能体现代码质量的部分。写得好的错误处理能让线上问题快速定位、让用户看到友好的提示;写得差的错误处理则会把真正的 bug 悄悄吞掉,等到用户投诉时才发现问题已经存在了几个月。

本文围绕五个核心主题展开:Error 类型体系、try/catch/finally 的正确用法、自定义错误、异步错误处理,以及全局兜底方案。每一部分都配有可直接运行的示例。

下面这张图概括了本文要讲的五层错误处理体系,从内到外逐层兜住错误:

业务代码

try/catch/finally 局部捕获

自定义错误 携带业务语义

异步错误处理 Promise / async-await

全局兜底 error / unhandledrejection

上报监控 + 降级提示

2. 认识 Error 类型

JavaScript 内置了多种错误类型,它们都继承自 Error。理解它们的语义,是写出可维护错误处理代码的第一步。

类型典型触发场景
Error通用错误,手动抛出时使用
TypeError值的类型不符合预期,如调用 undefined()
ReferenceError访问未声明的变量
RangeError数值超出允许范围,如 new Array(-1)
SyntaxError语法解析失败,如 JSON.parse('{')
URIErrorURI 编解码参数非法

Error 实例上有几个关键属性:

const err = new Error('请求超时');

console.log(err.message); // '请求超时'
console.log(err.name);    // 'Error'
console.log(err.stack);   // 包含调用栈的字符串,定位问题的主要依据

stack 属性是排查问题的核心。注意:stack 是 V8 等引擎的非标准扩展,但在主流运行时中普遍可用,生产环境建议上报它。

3. try/catch/finally 的正确用法

3.1 基本结构

try {
  const data = JSON.parse(rawInput);
  process(data);
} catch (err) {
  console.error('解析失败:', err);
} finally {
  cleanup();
}

finally 无论是否抛错都会执行,适合放资源释放逻辑,比如关闭连接、清除定时器、恢复 loading 状态。

try/catch/finally 的执行流程如下:

否

是

进入 try 块

是否抛出异常

执行 try 剩余语句

跳转到 catch 块

执行 finally 块

继续执行后续代码

3.2 常见误区

误区一:catch 里什么都不做。

// 反例:错误被静默吞掉
try {
  doSomething();
} catch (e) {}

这会让问题彻底消失,排查时毫无线索。至少要记录日志,或者明确注释说明为何可以忽略。

误区二:catch 住所有错误,不区分类型。

// 反例:把编程错误和业务错误混为一谈
try {
  const user = await fetchUser(id);
  render(user.profile.name);
} catch (e) {
  showToast('网络异常');
}

如果 user.profile 是 undefined,这里会抛 TypeError,但用户看到的是「网络异常」,误导了排查方向。正确做法是区分处理:

try {
  const user = await fetchUser(id);
  render(user.profile.name);
} catch (e) {
  if (e instanceof TypeError) {
    // 数据结构问题,属于 bug,需要上报
    reportError(e);
    throw e;
  }
  showToast('网络异常,请稍后重试');
}

误区三:在 finally 中 return。

// 反例:finally 的 return 会覆盖 try 中的返回值,甚至吞掉异常
function bad() {
  try {
    return 1;
  } finally {
    return 2; // 实际返回 2
  }
}

finally 中应只做清理,不要写 return、break、continue。

3.3 缩小 try 块范围

try 块越大,越难判断异常来自哪一行。尽量只包裹真正可能抛错的语句:

// 推荐
let data;
try {
  data = JSON.parse(rawInput);
} catch (e) {
  data = fallbackValue;
}
process(data); // 放在 try 外面

4. 自定义错误

内置错误类型无法表达业务语义。自定义错误能让调用方通过 instanceof 精确判断,也能携带额外上下文。

自定义错误的继承关系通常是这样组织的:

Error

+String message

+String name

+String stack

AppError

+String code

+Number statusCode

ValidationError

+String field

NetworkError

AuthError

4.1 基础写法

class AppError extends Error {
  constructor(message, options = {}) {
    super(message, options);
    this.name = 'AppError';
    this.code = options.code ?? 'UNKNOWN';
    this.statusCode = options.statusCode ?? 500;
  }
}

class ValidationError extends AppError {
  constructor(message, field) {
    super(message, { code: 'VALIDATION_FAILED', statusCode: 400 });
    this.name = 'ValidationError';
    this.field = field;
  }
}

使用:

function validateAge(age) {
  if (typeof age !== 'number' || age < 0) {
    throw new ValidationError('年龄必须是非负数字', 'age');
  }
  return age;
}

try {
  validateAge(-1);
} catch (e) {
  if (e instanceof ValidationError) {
    console.log(`字段 ${e.field} 校验失败:${e.message}`);
  }
}

4.2 保留原始错误链

包装底层错误时,用 cause 保留原始信息,避免丢失调用栈:

try {
  await db.query(sql);
} catch (err) {
  throw new AppError('数据库查询失败', { cause: err, code: 'DB_ERROR' });
}

cause 是 ES2022 引入的标准属性,可通过 err.cause 访问原始错误。

4.3 自定义错误的设计建议

  • 继承链保持浅层,一般 业务错误 -> AppError -> Error 足够。
  • 用 code 字段做机器可读的分类,message 面向人类阅读。
  • 不要把所有错误都塞进一个类,按领域拆分(如 NetworkError、AuthError、ValidationError)。

5. 异步错误处理

异步是 JavaScript 错误处理最容易出问题的地方,因为错误不会像同步代码那样自然冒泡到外层 try。

异步错误的传播路径与同步代码不同,可以用下图理解:

是

否

async 函数调用

返回 Promise

是否 await

错误进入外层 try/catch

产生 unhandled rejection

全局 unhandledrejection 兜底

按错误类型分别处理

5.1 Promise 的错误

// 反例:没有 catch,产生 unhandled rejection
fetch('/api/user').then((res) => res.json());

// 正确:链式 catch
fetch('/api/user')
  .then((res) => res.json())
  .catch((err) => {
    console.error('请求失败', err);
  });

5.2 async/await 的错误

await 让异步代码可以用 try/catch 捕获,这是最推荐的写法:

async function loadUser(id) {
  try {
    const res = await fetch(`/api/user/${id}`);
    if (!res.ok) {
      throw new AppError(`HTTP ${res.status}`, { code: 'HTTP_ERROR' });
    }
    return await res.json();
  } catch (err) {
    reportError(err);
    throw err; // 交给上层决定如何处理
  }
}

注意 fetch 只在网络层失败时 reject,HTTP 4xx/5xx 不会自动抛错,必须手动检查 res.ok。

5.3 并发请求的错误

Promise.all 中任意一个 reject 就会整体 reject,其余结果丢失。若希望拿到全部结果,用 Promise.allSettled:

const results = await Promise.allSettled(tasks);

for (const r of results) {
  if (r.status === 'rejected') {
    console.error('任务失败:', r.reason);
  } else {
    console.log('任务成功:', r.value);
  }
}

5.4 不要忘记 await

// 反例:忘记 await,错误永远不会被这个 try 捕获
try {
  saveData(); // 返回 Promise 但没 await
} catch (e) {
  console.error(e); // 不会执行
}

这类问题在代码审查中很难发现,建议开启 ESLint 的 no-floating-promises 规则。

6. 全局兜底

无论代码写得多严谨,总有遗漏。全局兜底是最后一道防线,用于捕获未处理的错误并上报,而不是用来替代局部处理。

全局兜底的整体链路如下:

浏览器

浏览器

Node.js

Node.js

未捕获错误

运行环境

window error 事件

unhandledrejection 事件

uncaughtException

unhandledRejection

上报监控平台

降级提示 / 进程重启

6.1 浏览器环境

// 捕获同步运行时错误和资源加载错误
window.addEventListener('error', (event) => {
  reportError({
    type: 'runtime',
    message: event.message,
    filename: event.filename,
    lineno: event.lineno,
    colno: event.colno,
    error: event.error,
  });
});

// 捕获未处理的 Promise rejection
window.addEventListener('unhandledrejection', (event) => {
  reportError({
    type: 'unhandledrejection',
    reason: event.reason,
  });
  // 可选:阻止控制台默认报错输出
  // event.preventDefault();
});

6.2 Node.js 环境

process.on('uncaughtException', (err) => {
  console.error('未捕获异常:', err);
  reportError(err);
  // 进程状态可能已不可信,记录后退出
  process.exit(1);
});

process.on('unhandledRejection', (reason) => {
  console.error('未处理的 Promise rejection:', reason);
  reportError(reason);
});

uncaughtException 之后进程状态可能已损坏,最佳实践是记录日志后尽快退出,由进程管理器重启,而不是继续运行。

6.3 全局兜底的定位

全局兜底应该做到三件事:

  1. 上报:把错误信息、堆栈、用户环境发送到监控平台。
  2. 降级:给用户一个可用的界面,而不是白屏。
  3. 不掩盖:不要用全局兜底替代局部 try/catch,否则真正的错误位置会被模糊掉。

7. 实践清单

把上面的要点浓缩成一份可执行的检查清单:

  • 每个 catch 都要有明确意图:处理、上报或重新抛出,禁止空 catch。
  • 用 instanceof 区分错误类型,不要把编程错误当成业务错误处理。
  • finally 只做清理,不写 return。
  • 自定义错误携带 code 和 cause,保持错误链完整。
  • 异步代码优先用 async/await + try/catch,并检查 res.ok。
  • 并发场景按需选择 Promise.all 或 Promise.allSettled。
  • 开启 no-floating-promises 等 lint 规则,防止漏写 await。
  • 全局兜底只做上报与降级,不替代局部处理。

8. 总结

错误处理的核心不是「让程序不报错」,而是「让错误在正确的地方被正确地处理」。内置 Error 类型提供了语义基础,try/catch/finally 提供了控制流,自定义错误提供了业务表达能力,异步处理补齐了 Promise 场景,全局兜底则守住了最后一道防线。

把这五层组合起来,才能构建出既健壮又可维护的 JavaScript 错误处理体系。

转载自 CSDN-专业IT技术社区

原文链接:https://blog.csdn.net/vipxieliang/article/details/171042693

文章来源转载

评论

评论列表

微信小程序
QQ小程序

关于作者

点赞数:0
关注数:0
粉丝:0
文章:0
关注标签:0
加入于:--