当前位置：首页 > 文章列表 > 文章 > 前端 > 手写Promise原理及源码分析

手写Promise原理及源码分析

2026-04-24 19:27:38 0浏览收藏

本文深入浅出地剖析了 Promise 的底层实现原理，通过手写一个符合 Promise/A+ 规范的简易 MyPromise，清晰展现了状态机（pending/fulfilled/rejected）的不可逆性、then 方法如何支持链式调用与异步微任务调度（借助 queueMicrotask）、resolvePromise 对返回值的递归解析逻辑（兼容普通值与嵌套 Promise）、以及关键的健壮性保障机制——如循环引用检测、调用防重复、错误冒泡和异常捕获；读完不仅能彻底摆脱“黑盒”认知，更能夯实异步编程根基，在实际开发中更自信地驾驭 Promise 及其衍生生态。

手写Promise核心原理及源码实现_javascript技巧

Promise 是 JavaScript 中处理异步操作的核心机制，理解其底层原理有助于更好地掌握异步编程。下面从手写一个简易但核心功能完整的 Promise 出发，深入剖析其实现逻辑。

Promise 核心特性与状态机

一个符合 Promise/A+ 规范的实现必须满足以下几点：

Promise 有三种状态：pending（等待）、fulfilled（成功）、rejected（失败）
状态只能由 pending 转为 fulfilled 或 rejected，且一旦确定不可逆
通过 then 方法注册成功和失败的回调，支持链式调用
then 的回调函数是异步执行的（微任务）

我们基于这些规则来实现一个简化版的 MyPromise。

基础结构与状态管理

先定义构造函数和基本状态：

function MyPromise(executor) {
  this.state = 'pending';
  this.value = undefined;
  this.reason = 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.reason = reason;
      this.onRejectedCallbacks.forEach(fn => fn());
    }
  };

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

这里通过数组缓存未执行的回调，确保在异步 resolve/reject 后仍能正确触发。

实现 then 方法

then 方法是 Promise 的核心，需返回一个新的 Promise 以支持链式调用：

MyPromise.prototype.then = function(onFulfilled, onRejected) {
  onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : val => val;
  onRejected = typeof onRejected === 'function' ? onRejected : err => { throw err; };

  const promise2 = new MyPromise((resolve, reject) => {
    if (this.state === 'fulfilled') {
      queueMicrotask(() => {
        try {
          const x = onFulfilled(this.value);
          resolvePromise(promise2, x, resolve, reject);
        } catch (e) {
          reject(e);
        }
      });
    }

    if (this.state === 'rejected') {
      queueMicrotask(() => {
        try {
          const x = onRejected(this.reason);
          resolvePromise(promise2, x, resolve, reject);
        } catch (e) {
          reject(e);
        }
      });
    }

    if (this.state === 'pending') {
      this.onFulfilledCallbacks.push(() => {
        queueMicrotask(() => {
          try {
            const x = onFulfilled(this.value);
            resolvePromise(promise2, x, resolve, reject);
          } catch (e) {
            reject(e);
          }
        });
      });

      this.onRejectedCallbacks.push(() => {
        queueMicrotask(() => {
          try {
            const x = onRejected(this.reason);
            resolvePromise(promise2, x, resolve, reject);
          } catch (e) {
            reject(e);
          }
        });
      });
    }
  });

  return promise2;
};

注意使用 queueMicrotask 模拟微任务执行，保证回调异步且优先于 setTimeout。

处理返回值与链式传递

Promise 链的关键在于 resolvePromise 函数，它决定如何处理 then 回调的返回值：

function resolvePromise(promise2, x, resolve, reject) {
  if (promise2 === x) {
    return reject(new TypeError('Chaining cycle detected'));
  }

  let called;
  if (x != null && (typeof x === 'object' || typeof x === 'function')) {
    try {
      const then = x.then;
      if (typeof then === 'function') {
        then.call(x, y => {
          if (called) return;
          called = true;
          resolvePromise(promise2, y, resolve, reject);
        }, r => {
          if (called) return;
          called = true;
          reject(r);
        });
      } else {
        resolve(x);
      }
    } catch (e) {
      if (called) return;
      called = true;
      reject(e);
    }
  } else {
    resolve(x);
  }
}

这段逻辑判断返回值是否为 Promise，如果是则递归解析，否则直接 resolve。

基本上就这些。虽然省略了 catch、finally、all、race 等方法，但核心机制已完整。手写一遍能真正理解 Promise 如何解决回调地狱、实现链式调用和错误冒泡。不复杂但容易忽略细节，比如循环引用、多次调用保护、异步调度等。

终于介绍完啦！小伙伴们，这篇关于《手写Promise原理及源码分析》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识，快来关注吧！