异步时代的错误处理：超越 try-catch 的 Promise.try

在现代 JavaScript 开发中，错误处理一直是不可忽视的问题。传统的 try-catch 语法虽然简单直观，但在异步场景下却存在明显局限。本文将带你理解 try-catch 的局限性，并介绍 Promise.try 这一统一处理同步和异步错误的新方案。

1. try-catch 的局限性

1.1 异步错误无法捕获

在传统的 try-catch 中，如果错误发生在异步操作里，它将无法被捕获：

try {
  setTimeout(() => {
    throw new Error('异步错误'); // 这个错误不会被 catch 捕获
  }, 0);
} catch (error) {
  console.error('这里永远不会执行:', error);
}

上例中，错误发生在 setTimeout 回调中，属于异步执行，try-catch 无法捕获。

1.2 Promise 错误处理复杂

虽然 Promise 提供了 .catch() 方法，但当同步和异步逻辑混合时，错误处理逻辑会变得冗长和分散：

function riskyOperation() {
  if (Math.random() > 0.5) throw new Error('同步错误');
  return Promise.resolve('异步结果');
}

riskyOperation()
  .then(res => console.log(res))
  .catch(err => console.error('捕获错误:', err));

你需要区分同步错误和异步错误，容易出现遗漏。

2. Promise.try：统一同步与异步错误处理

Promise.try 是一种实用工具，虽然还未成为标准，但已在一些库（如 Bluebird）中实现，并有望纳入未来标准。

2.1 基本概念

Promise.try(fn) 接受一个函数 fn，无论函数返回同步值还是 Promise，都能将结果“提升”为 Promise。这样所有错误都能通过 .catch() 捕获：

Promise.try(() => {
  // 同步操作
  if (Math.random() > 0.5) throw new Error('同步错误');
  return '成功结果';
})
.then(res => console.log('结果:', res))
.catch(err => console.error('捕获错误:', err));

优点：

同步和异步错误统一处理。
结构简洁，避免 try-catch 与 Promise 链混合。
微任务调度，保证执行顺序更一致。

2.2 微任务执行顺序示例

console.log('开始');

Promise.try(() => {
  console.log('Promise.try执行');
  return 'result';
})
.then(result => console.log('处理结果:', result));

console.log('同步代码结束');

// 输出顺序：
// "开始"
// "Promise.try执行"
// "同步代码结束"
// "处理结果: result"

可以看到，Promise.try 将函数放入微任务队列，确保同步逻辑完成后再处理，然后进入 Promise 链。

3. 适用场景

混合同步/异步逻辑：函数中可能抛出同步错误，同时也返回 Promise。
统一错误处理：减少 try-catch 与 .catch() 混用，提高代码可读性。
微任务调度：在复杂异步链中，保证执行顺序一致。

4. 小结

传统 try-catch 在同步错误处理上依然有效，但对于异步操作和混合逻辑，它显得不够优雅。Promise.try 提供了一种现代化的解决方案，让开发者可以统一捕获错误、简化代码结构、保持执行顺序一致。

随着 JavaScript 的发展，未来可能会有更多类似的实用工具被标准化，帮助我们写出更安全、更简洁、更高效的异步代码。

如果你希望，我可以帮你写一个 完整可运行的示例 HTML 页面，演示 try-catch、Promise .catch() 与 Promise.try 在同步和异步错误捕获上的对比效果。

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <title>JavaScript 错误处理对比示例</title>
  <style>
    body { font-family: "Microsoft YaHei", sans-serif; padding: 20px; }
    h2 { margin-top: 20px; color: #2c3e50; }
    pre { background: #f4f4f4; padding: 10px; border-radius: 5px; }
  </style>
</head>
<body>
  <h1>JavaScript 错误处理对比</h1>

  <h2>1. try-catch 捕获同步错误</h2>
  <pre id="tryCatchSync"></pre>

  <h2>2. try-catch 捕获异步错误（无法捕获）</h2>
  <pre id="tryCatchAsync"></pre>

  <h2>3. Promise.catch 捕获异步错误</h2>
  <pre id="promiseCatch"></pre>

  <h2>4. Promise.try 统一捕获同步和异步错误</h2>
  <pre id="promiseTry"></pre>

  <script>
    const log = (id, msg) => {
      document.getElementById(id).textContent += msg + '\n';
    };

    // 1. try-catch 捕获同步错误
    try {
      throw new Error('同步错误');
    } catch (err) {
      log('tryCatchSync', `捕获到错误: ${err.message}`);
    }

    // 2. try-catch 捕获异步错误（无法捕获）
    try {
      setTimeout(() => {
        throw new Error('异步错误');
      }, 0);
      log('tryCatchAsync', 'setTimeout 异步执行，try-catch 无法捕获');
    } catch (err) {
      log('tryCatchAsync', `捕获到错误: ${err.message}`);
    }

    // 3. Promise.catch 捕获异步错误
    new Promise((resolve, reject) => {
      setTimeout(() => reject(new Error('Promise 异步错误')), 100);
    })
    .catch(err => {
      log('promiseCatch', `捕获到错误: ${err.message}`);
    });

    // 4. Promise.try 统一捕获同步和异步错误
    // 简单 polyfill，用于示例（真实项目可用 Bluebird）
    Promise.try = function(fn) {
      return new Promise((resolve) => resolve()).then(fn);
    };

    Promise.try(() => {
      log('promiseTry', '执行同步逻辑...');
      if (Math.random() > 0.5) throw new Error('同步错误');
      return new Promise((resolve, reject) => {
        setTimeout(() => reject(new Error('异步错误')), 100);
      });
    })
    .then(res => log('promiseTry', `处理结果: ${res}`))
    .catch(err => log('promiseTry', `捕获到错误: ${err.message}`));

  </script>
</body>
</html>

复制全文生成海报 JavaScript 错误处理异步编程

编程 异步时代的错误处理：超越 try-catch 的 Promise.try