JavaScript错误处理进化：从 try-catch 到 Promise.try

在JavaScript开发中，错误处理始终是绕不开的重要课题。传统的 try-catch 虽然简单易用，但在处理异步代码时存在明显局限。本文将深入剖析这些问题，并介绍一种更优雅的解决方案——Promise.try。

传统 try-catch 的局限性

1. 无法捕获异步错误

try-catch 只能捕获同步代码中的异常，对于异步操作抛出的错误，无法捕获。例如：

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

上例中，setTimeout 中的错误不会被外层 catch 捕获，因为异常发生在异步执行阶段。

2. Promise 中同步异步错误混杂处理繁琐

虽然 Promise 本身提供了 .catch() 方法，但当函数内部既有同步抛错又有异步错误时，需要分别处理同步异常和异步异常，导致代码混乱且易出错。

示例：

function fetchData(id) {
  // 同步错误检查
  if (!id) {
    throw new Error('ID不能为空');
  }

  return fetch(`/api/data/${id}`)
    .then(response => {
      if (!response.ok) {
        throw new Error('请求失败');
      }
      return response.json();
    });
}

// 调用时
try {
  fetchData(null)
    .then(data => {
      console.log('数据:', data);
    })
    .catch(error => {
      console.error('Promise异步错误:', error);
    });
} catch (error) {
  console.error('同步错误:', error);
}

可以看到，既要包裹 try-catch，又要链式 .catch()，代码冗长，且容易遗漏错误处理。

什么是 Promise.try？

为了统一同步和异步错误处理，许多第三方库（如 Bluebird）引入了 Promise.try 概念。

⚡ 需要注意的是，Promise.try 并不是 ECMAScript 标准的一部分，目前官方（TC39）也没有将其标准化的计划。

基本概念：
Promise.try 接受一个函数参数，无论该函数返回同步值还是Promise对象，都会被自动提升为Promise，从而统一后续的错误捕获流程。

示例：

Promise.try(() => {
  // 同步或异步代码
  return someValue; // 返回同步值
  // 或 return somePromise;
})
.then(result => {
  // 成功处理
})
.catch(error => {
  // 捕获所有错误
});

Promise.try 的优势

1. 统一同步与异步错误处理

无论同步错误还是异步错误，统一通过 .catch() 捕获，不再需要外部 try-catch。

示例：

Promise.try(() => {
  if (!id) {
    throw new Error('ID不能为空'); // 同步抛错
  }
  return fetch(`/api/data/${id}`).then(r => r.json()); // 异步操作
})
.then(data => {
  console.log('数据:', data);
})
.catch(error => {
  console.error('统一捕获的错误:', error);
  return Promise.reject(error); // 保持错误链
});

2. 保持代码结构一致，简化复杂逻辑

使用 Promise.try 后，函数内部无需分开处理同步和异步异常，结构统一，逻辑清晰。

传统写法（混杂同步异步处理）：

function processData(input) {
  try {
    validateInput(input);
    return fetchExternalData(input)
      .then(processResult)
      .catch(handleAsyncError);
  } catch (error) {
    return Promise.reject(handleSyncError(error));
  }
}

使用 Promise.try 改进：

function processData(input) {
  return Promise.try(() => {
    validateInput(input);
    return fetchExternalData(input);
  })
  .then(processResult)
  .catch(error => {
    return handleError(error);
  });
}

结构整洁，错误处理统一，易维护。

3. 微任务调度一致性

在执行流程上，Promise.try 会立即执行传入的函数，如果抛出同步异常，会立即 reject。后续 .then()、.catch() 属于微任务队列执行，保证了执行时序的一致性。

示例：

console.log('开始');

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

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

输出顺序：

开始
Promise.try执行
同步代码结束
处理结果: result

✅ 注意：Promise.try 本身不会推迟函数执行，只是后续的 .then / .catch 是微任务。

如何自己实现 Promise.try？

如果不使用 Bluebird，也可以自己简单封装一个 Promise.try：

Promise.try = function (fn) {
  return new Promise((resolve, reject) => {
    try {
      resolve(fn());
    } catch (error) {
      reject(error);
    }
  });
};

这样就可以在原生环境下体验统一的错误处理了！

下面直观做个比较：

特性	传统 try-catch	Promise.try
异步错误捕获	❌ 需要额外处理	✅ 统一 .catch
同步异步统一	❌ 不统一，容易混乱	✅ 同一链式流程
代码结构	❌ try-catch + Promise.catch 混合	✅ 清爽统一
调度时序	✅同步/异步不一致	✅微任务一致
标准支持	✅	❌（第三方库特性）

Promise.try 的实际应用场景

在实际项目开发中，Promise.try 尤其适用于同步异步混合、批量异步处理、需要统一错误捕获的场景。以下是几个典型应用示例：

1. 表单校验与提交

常规问题： 表单提交通常需要先同步校验（字段合法性），再异步发送请求，期间可能出现同步错误（字段非法）或异步错误（接口失败）。传统写法容易出错，需要写两层处理。

使用 Promise.try：

function submitForm(formData) {
  return Promise.try(() => {
    validateForm(formData); // 同步校验，可能抛错
    return apiSubmit(formData); // 异步提交，返回Promise
  })
  .then(response => {
    console.log('提交成功:', response);
  })
  .catch(error => {
    console.error('提交失败:', error);
    // 可以根据错误类型区分处理
    handleFormError(error);
  });
}

function validateForm(data) {
  if (!data.username) {
    throw new Error('用户名不能为空');
  }
  // 其他同步验证...
}

function apiSubmit(data) {
  return fetch('/api/submit', {
    method: 'POST',
    body: JSON.stringify(data),
    headers: {'Content-Type': 'application/json'}
  }).then(res => {
    if (!res.ok) {
      throw new Error('服务器响应异常');
    }
    return res.json();
  });
}

✅ 优势总结：

• 同步/异步错误全部 .catch() 统一捕获
• 表单校验逻辑和提交逻辑自然衔接，无需 try-catch 包裹

2. 批量异步请求处理

常规问题： 多个异步请求批量发出（比如上传多张图片、拉取多个接口数据），中间如果单个请求失败，需要统一处理错误，不希望因为某个同步处理逻辑问题导致整个批次异常。

使用 Promise.try + Promise.all：

function batchFetch(urls) {
  return Promise.try(() => {
    if (!Array.isArray(urls)) {
      throw new Error('参数必须是数组');
    }
    
    const requests = urls.map(url =>
      fetch(url).then(res => {
        if (!res.ok) {
          throw new Error(`请求失败: ${url}`);
        }
        return res.json();
      })
    );
    
    return Promise.all(requests);
  })
  .then(results => {
    console.log('所有请求成功:', results);
  })
  .catch(error => {
    console.error('批量请求出错:', error);
  });
}

// 调用
batchFetch(['/api/data1', '/api/data2', '/api/data3']);

✅ 优势总结：

• 输入验证（同步）错误和请求失败（异步）错误统一处理
• Promise.all 出错时快速 fail fast，且异常流程清晰统一

3. 统一中间件风格封装

如果你在做 Node.js 后端开发，比如用 Koa / Express，也可以用 Promise.try 风格统一中间件的异常处理：

async function controllerWrapper(controllerFn) {
  return async (req, res, next) => {
    Promise.try(() => controllerFn(req, res))
      .catch(next); // 自动走到 Express 的错误处理中间件
  };
}

// 使用
app.get('/api/user', controllerWrapper(async (req, res) => {
  if (!req.query.id) {
    throw new Error('缺少用户ID');
  }
  const user = await getUserById(req.query.id);
  res.json(user);
}));

✅ 优势总结：

• 不需要在每个 controller 写 try-catch
• 异步同步错误全部安全传递到全局错误处理中间件

只要你的逻辑中既涉及同步判断、又涉及异步操作，想要统一优雅的异常处理，都可以考虑用 Promise.try！