一、Promise 的核心状态机

Promise 本质上是一个状态机，其行为由内部状态严格管控。每个 Promise 实例在创建时处于 Pending（等待） 状态，此时异步操作尚未完成。当异步操作成功完成时，Promise 通过调用 resolve(value) 转换为 Fulfilled（已兑现） 状态；若操作失败或显式调用 reject(reason)，则状态变为 Rejected（已拒绝）。状态一旦转换便不可逆，这种不可变性确保了异步流程的可靠性。

代码示例：基础状态转换

const promise = new Promise((resolve, reject) => {
  // 异步操作（如 API 请求）
  setTimeout(() => {
    const success = true;
    if (success) {
      resolve("操作成功"); // 状态变为 Fulfilled
    } else {
      reject("操作失败"); // 状态变为 Rejected
    }
  }, 1000);
});

二、执行器函数的同步执行与异步调度

Promise 的构造函数接收一个 executor 函数，该函数在 Promise 实例化时立即同步执行。此特性意味着，executor 中的同步代码会直接在当前调用栈中运行，而异步操作（如 setTimeout 或网络请求）则通过事件循环机制延迟处理。resolve 和 reject 作为两个关键函数，用于在异步操作完成后触发状态变更。

代码示例：同步与异步行为对比

console.log("开始创建 Promise");
const promise = new Promise((resolve) => {
  console.log("执行器同步执行");
  setTimeout(() => {
    resolve("异步操作完成"); // 异步触发状态变更
  }, 0);
});
console.log("Promise 创建完毕");
// 输出顺序：
// 开始创建 Promise → 执行器同步执行 → Promise 创建完毕 → （异步触发 resolve）

三、微任务队列与回调调度

当 Promise 的状态从 Pending 转换为 Fulfilled 或 Rejected 时，所有通过 .then() 或 .catch() 注册的回调函数会被推入 微任务队列（Microtask Queue）。微任务队列的优先级高于宏任务队列（如 setTimeout），这意味着 Promise 回调总是在当前事件循环的末尾、下一个宏任务之前执行。这一机制确保了异步代码的及时性和可预测性。

代码示例：微任务与宏任务执行顺序

console.log("主线程开始");

setTimeout(() => {
  console.log("宏任务回调");
}, 0);

Promise.resolve().then(() => {
  console.log("微任务回调");
});

console.log("主线程结束");
// 输出顺序：
// 主线程开始 → 主线程结束 → 微任务回调 → 宏任务回调

四、链式调用的实现原理

Promise 的链式调用通过 .then() 方法实现。每次调用 .then() 会返回一个新的 Promise 实例，使得多个异步操作可以按顺序串联。链式调用的核心规则如下：

1. 若前一个回调返回普通值（非 Promise），新 Promise 将直接以该值兑现。
2. 若返回另一个 Promise，则新 Promise 的状态由该内部 Promise 决定。
3. 若抛出异常，新 Promise 会被拒绝。

代码示例：链式调用与值传递

fetchData() // 假设返回一个 Promise
  .then((data) => {
    console.log("第一步处理", data);
    return processData(data); // 返回新值或 Promise
  })
  .then((result) => {
    console.log("第二步处理", result);
  })
  .catch((error) => {
    console.error("捕获错误", error);
  });

五、错误冒泡与统一处理

Promise 的错误处理遵循“冒泡”机制。链式调用中的任何一个环节抛出错误（无论是显式调用 reject 还是抛出异常），错误都会沿着调用链向下传递，直到被 .catch() 捕获。这一特性避免了传统回调中错误处理的冗余代码，使得异常管理更为集中。

代码示例：错误冒泡

new Promise((resolve, reject) => {
  throw new Error("初始错误");
})
  .then(() => {
    console.log("此回调不会执行");
  })
  .then(() => {
    console.log("此回调也不会执行");
  })
  .catch((error) => {
    console.log("捕获错误:", error.message); // 输出：捕获错误: 初始错误
  });

六、静态方法与工具函数

Promise 提供多个静态方法以简化常见场景的处理：

• Promise.resolve(value)：快速创建一个已兑现的 Promise。
• Promise.reject(reason)：快速创建一个已拒绝的 Promise。
• Promise.all(iterable)：等待所有 Promise 完成，任一失败则整体失败。
• Promise.race(iterable)：取最先完成的 Promise 结果（无论成功或失败）。

代码示例：Promise.all 实现并行处理

const fetchUser = fetch("/api/user");
const fetchPosts = fetch("/api/posts");

Promise.all([fetchUser, fetchPosts])
  .then((responses) => {
    const [userResponse, postsResponse] = responses;
    return Promise.all([userResponse.json(), postsResponse.json()]);
  })
  .then(([user, posts]) => {
    console.log("用户数据:", user);
    console.log("文章数据:", posts);
  })
  .catch((error) => {
    console.error("请求失败:", error);
  });

七、手写简化版 Promise 核心逻辑

为深入理解 Promise 的内部机制，以下实现一个简化的 Promise 类，包含状态管理、回调队列和链式调用支持：

class SimplePromise {
  constructor(executor) {
    this.state = "pending";
    this.value = undefined;
    this.onFulfilledCallbacks = [];
    this.onRejectedCallbacks = [];

    const resolve = (value) => {
      if (this.state === "pending") {
        this.state = "fulfilled";
        this.value = value;
        this.onFulfilledCallbacks.forEach((fn) => fn());
      }
    };

    const reject = (reason) => {
      if (this.state === "pending") {
        this.state = "rejected";
        this.value = reason;
        this.onRejectedCallbacks.forEach((fn) => fn());
      }
    };

    try {
      executor(resolve, reject);
    } catch (error) {
      reject(error);
    }
  }

  then(onFulfilled, onRejected) {
    const newPromise = new SimplePromise((resolve, reject) => {
      const handleCallback = (callback, value) => {
        // 使用 queueMicrotask 模拟微任务
        queueMicrotask(() => {
          try {
            const result = callback ? callback(value) : value;
            // 处理返回值可能为 Promise 的情况
            if (result instanceof SimplePromise) {
              result.then(resolve, reject);
            } else {
              resolve(result);
            }
          } catch (error) {
            reject(error);
          }
        });
      };

      if (this.state === "fulfilled") {
        handleCallback(onFulfilled, this.value);
      } else if (this.state === "rejected") {
        handleCallback(onRejected, this.value);
      } else {
        this.onFulfilledCallbacks.push(() => handleCallback(onFulfilled, this.value));
        this.onRejectedCallbacks.push(() => handleCallback(onRejected, this.value));
      }
    });

    return newPromise;
  }
}

八、总结

Promise 的设计围绕 状态隔离 和 异步调度 展开，通过微任务队列确保回调的高效执行。其链式调用和错误冒泡机制大幅简化了异步代码的复杂度，而静态方法则为常见场景提供了开箱即用的解决方案。理解 Promise 的内部逻辑（如状态机、微任务优先级）有助于开发者更高效地处理异步任务，并为后续学习 async/await 语法奠定基础。