Promise异常未阻止执行的原因解析

今日不肯埋头，明日何以抬头！每日一句努力自己的话哈哈~哈喽，今天我将给大家带来一篇《Promise 异常未阻止脚本执行的原因在于 JavaScript 的异步机制。以下是详细解释：1. Promise 是异步的Promise 是 JavaScript 中处理异步操作的一种方式。当一个 Promise 被创建并执行时，它会在事件循环中被安排执行，而不是立即阻塞后续代码。new Promise((resolve, reject) => { throw new Error("出错了"); }).catch(err => console.error(err)); console.log("后续代码");在这个例子中，虽然 Promise 内部抛出了异常，但由于它是异步执行的，不会阻塞后续同步代码的执行，因此 console.log("后续代码") 仍然会正常运行。2. 未捕获的异常会被忽略如果 Promise 中抛出的异常没有被 .catch() 或 try/catch 捕获，那么该异常会被静默丢弃（在浏览器中），不会导致整个程序崩溃。new Promise((resolve, reject) => { throw new Error("未捕获的错误"); }); console.log("后续代码"); // 仍然执行这在某些情况下可能会导致难以调试的问题，所以建议始终使用 .catch() 来捕获可能的错误。3. 与同步代码的区别如果你在同步代码中抛》，主要内容是讲解等等，感兴趣的朋友可以收藏或者有更好的建议在评论提出，我都会认真看的！大家一起进步，一起学习！

Promise 构造函数内部的同步执行器（executor）中抛出的异常会被 Promise 机制捕获并处理，将 Promise 的状态设置为 rejected，但不会立即中断后续脚本的执行。这是因为 Promise 内部已经对异常进行了处理，避免了程序崩溃，允许后续代码继续运行。本文将深入探讨这一机制，并提供示例代码进行说明。

在学习 Promise 构造函数时，可能会遇到一个看似违反直觉的现象：在 new Promise() 内部的执行器函数中抛出异常，程序并没有立即停止，而是继续执行了后续的代码。

例如以下代码：

console.log('first');
const promise1 = new Promise((resolve, reject) => {
  console.log('inside executor');
  let what = 1
  console.log(what());
  console.log('not reached');
  resolve('Hi Guys!');
});
console.log('continues'); // 为什么会继续执行？

这段代码的输出结果是：

first
inside executor
continues
Uncaught (in promise) TypeError: what is not a function
  at index.js:5:15
  at new Promise ()

可以看到，尽管 what() 导致了 TypeError 异常，但 console.log('continues') 仍然被执行了。 这背后的原因在于 Promise 内部对异常的处理机制。

Promise 的异常处理机制

Promise 构造函数接收一个执行器函数（executor）作为参数。 这个执行器函数会立即同步执行。如果执行器函数内部抛出了异常，Promise 内部会捕获这个异常，并将 Promise 的状态设置为 rejected。 重要的是，这个捕获和状态变更是在 Promise 内部完成的，不会直接中断外部代码的执行。

根据 ECMAScript 规范，Promise 构造函数的具体步骤如下：

1. 创建一个新的 Promise 对象。
2. 调用执行器函数，并传入 resolve 和 reject 两个函数作为参数。
3. 如果执行器函数执行过程中抛出了异常，则调用 reject 函数，并将异常作为参数传递给它。
4. 返回新创建的 Promise 对象。

关键在于，即使执行器函数抛出了异常，Promise 构造函数仍然会正常返回 Promise 对象，而不会立即中断后续代码的执行。

模拟 Promise 内部实现

为了更好地理解 Promise 的异常处理机制，我们可以简单地模拟 Promise 构造函数的内部实现：

class MyPromise {
    #state
    #resolvedValue
    #customers

    constructor(executor) {
        this.#state = "pending";
        this.#customers = [];
        try {
             executor((value) => this.#resolve(value), 
                      (reason) => this.#reject(reason));
        } catch(err) {
             this.#reject(err); 
        }
    }

    #reject(reason) {
        if (this.#state !== "pending") return;
        this.#state = "rejected";
        this.#resolvedValue = reason;
        this.#broadcast();
    }
}

在这个模拟实现中，try...catch 块捕获了执行器函数中可能抛出的异常，并调用 #reject 方法将 Promise 的状态设置为 rejected。 即使发生了异常，constructor 函数仍然会正常返回。

如何处理 Promise 的 rejected 状态

虽然 Promise 内部捕获了异常，但我们仍然需要处理 Promise 的 rejected 状态。 通常使用 .catch() 方法或者 async/await 结构中的 try...catch 块来处理。

例如：

console.log('first');
const promise1 = new Promise((resolve, reject) => {
  console.log('inside executor');
  let what = 1
  console.log(what());
  console.log('not reached');
  resolve('Hi Guys!');
}).catch(error => {
  console.error("Promise rejected:", error);
});
console.log('continues');

或者使用 async/await：

async function myFunction() {
  console.log('first');
  try {
    const result = await new Promise((resolve, reject) => {
      console.log('inside executor');
      let what = 1
      console.log(what());
      console.log('not reached');
      resolve('Hi Guys!');
    });
    console.log("Promise resolved:", result);
  } catch (error) {
    console.error("Promise rejected:", error);
  }
  console.log('continues');
}

myFunction();

总结

Promise 构造函数内部的执行器函数中抛出的异常不会立即中断后续脚本的执行，这是因为 Promise 内部对异常进行了捕获和处理。为了处理 Promise 的 rejected 状态，我们需要使用 .catch() 方法或者 async/await 结构中的 try...catch 块。 这种机制使得 Promise 能够更好地处理异步操作中的异常，避免程序崩溃。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Promise异常未阻止执行的原因解析》文章吧，也可关注golang学习网公众号了解相关技术文章。