ES6+中Promise 中错误捕捉详解——链式调用catch（）或者async/await+try/catch

通过 unhandledrejection 捕捉未处理的 Promise 异常，手动将其抛出，最终让 window.onerror 捕捉，从而统一所有异常的处理逻辑
规范代码：catch（onRejected）、async...await+try...catch

在 JavaScript 的 Promise 中，错误是否会影响外部代码的执行，取决于是否通过 .catch() 方法或 try/catch 主动捕获错误。以下是详细分析：

一、Promise 内部错误的默认行为

未捕获的 Promise 错误不会影响外部代码执行

Promise 内部的错误（如 reject() 或 throw）如果没有被 .catch() 捕获，不会传播到外部的同步代码或全局作用域，外部代码（如 setTimeout、console.log 等）会继续执行。
示例：

     const p = new Promise((resolve, reject) => {
     reject(new Error("内部错误")); // 未捕获
   });
   setTimeout(() => console.log("外部代码执行"), 1000); // 仍会输出

现象：控制台会打印 Uncaught (in promise) Error: 内部错误，但 setTimeout 回调仍会执行。

Node.js 的全局处理机制

在 Node.js 中，未捕获的 Promise 拒绝会触发 unhandledRejection 事件，但默认不会终止进程（退出码仍为 0）。未来版本可能直接终止进程并返回非零退出码。

二、错误如何传递到外部？

主动使用 .catch() 捕获错误

通过链式调用 .catch()，可以捕获 Promise 链中任何位置的错误，并阻止错误传播到外部：

  someAsyncFunction()
 .then(() => { / 成功逻辑 / })
 .catch((err) => {
   console.error("捕获错误:", err); // 错误在此处理
 });

未捕获的异步错误会冒泡到全局

如果错误在 异步操作（如 setTimeout） 中抛出，则会被视为全局未捕获错误：

   new Promise((resolve) => {
     setTimeout(() => { 
       throw new Error("异步错误"); // 会被全局捕获
     }, 0);
   });

try/catch 无法捕获 Promise 内部错误

Promise 的错误是异步的，传统的 try/catch 无法捕获其内部错误：

   try {
     new Promise((resolve, reject) => {
       reject(new Error("错误"));
     });
   catch (err) {
     console.log("这里不会执行"); // 无效
  }

三、最佳实践

始终添加 .catch()

在 Promise 链末尾添加 .catch()，避免未捕获的拒绝：

 fetchData()
 .then(processData)
 .catch((err) => console.error("全局捕获:", err));

结合 async/await 和 try/catch

使用 async/await 时，可通过 try/catch 捕获错误：

   async function main() {
     try {
       const data = await fetchData();
     catch (err) {
       console.error("捕获错误:", err);
  }

全局错误监听（Node.js）

监听 unhandledRejection 事件处理未捕获的 Promise 错误：

    process.on("unhandledRejection", (err) => {
     console.error("未处理的 Promise 拒绝:", err);
   });

四、总结

默认行为：Promise 内部的未捕获错误不会影响外部代码执行，但会导致控制台警告。

主动处理：必须通过 .catch() 或 async/await + try/catch 捕获错误。

全局影响：在 Node.js 中，未捕获的 Promise 拒绝可能影响进程退出码（未来版本）。

这是一个非常经典的问题，涉及 Promise 的错误处理机制 和 同步 vs 异步代码的差异。

🔍 问题描述：

你发现：

• 用 async/await + try/catch 能捕捉错误 ✅
• 但用 传统 try/catch 包裹一个 未 await 的 Promise，却无法捕捉错误 ❌

✅ async/await + try/catch 可以捕捉错误的例子：

async function example() {
  try {
    await Promise.reject(new Error("出错了"));
  } catch (err) {
    console.log("捕获错误：", err.message);
  }
}
example();

输出：

捕获错误： 出错了

❌ 用普通 try/catch 包裹 Promise 不会捕获：

try {
  Promise.reject(new Error("出错了"));
} catch (err) {
  console.log("捕获错误：", err.message);
}

什么都不会输出！

🧠 原因解释：

1. try/catch 只能捕捉“同步”代码抛出的异常

JavaScript 中，try/catch 是同步的控制结构：

try {
  throw new Error("同步错误");  // ✅ 能捕捉
} catch (e) {
  console.log("同步捕捉：", e.message);
}

但 Promise 错误是异步执行栈上的错误，一旦进入微任务队列或宏任务队列，就不再处于 try/catch 的同步作用域里了。

2. Promise 的错误在异步链中传播

下面这段代码中的错误是“异步的”：

Promise.reject(new Error("异步错误"));

即使你在外层加 try/catch，JavaScript 已经执行完当前同步栈，Promise 的 .then/.catch 或 await 的处理，是在下一轮微任务里发生的。

✅ 正确做法：两种方式捕捉 Promise 错误

方法 1：使用 .catch()

Promise.reject(new Error("出错了"))
  .catch(err => console.log("用 .catch 捕获错误：", err.message));

方法 2：使用 await + try/catch

async function run() {
  try {
    await Promise.reject(new Error("出错了"));
  } catch (err) {
    console.log("用 async/await 捕获错误：", err.message);
  }
}

✅ 总结记忆：

如果你还想看运行栈图或者事件循环流程，我也可以帮你画图解释 😄