实现PromiseA+规范的完整指南

对于一个文章开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《实现一个符合 Promise A+ 规范的 Promise 类需要理解其核心机制和状态转换规则。以下是实现的基本思路和步骤：一、Promise 的基本概念Promise 是一种用于处理异步操作的对象，它有三种状态：Pending（进行中）：初始状态，既不是成功也不是失败。Fulfilled（已成功）：表示操作成功完成。Rejected（已失败）：表示操作失败。一旦状态改变，就不可再变。二、Promise A+ 规范的关键点根据 Promise A+ 规范，一个 Promise 对象必须具备以下特性：then 方法接收两个参数：onFulfilled 和 onRejected。then 方法返回一个新的 Promise。如果 onFulfilled 或 onRejected 返回一个值，新 Promise 应该以该值为结果。如果 onFulfilled 或 onRejected 抛出异常，新 Promise 应该以该异常为拒绝原因。如果 onFulfilled 或 onRejected 返回一个 Promise，新 Promise 应该等待该 Promise 的结果。三、实现思路我们可以按照以下结构来实现一个简单的 Promise 类： class MyPromise { constructor(executor) { this.state》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

实现一个符合 Promise A+ 规范的 Promise 类，需定义 pending、fulfilled、rejected 三种不可逆状态，通过 resolve 和 reject 函数改变状态并执行对应回调；then 方法返回新 Promise 实现链式调用，根据当前状态异步执行 onFulfilled 或 onRejected，并将结果传入 resolvePromise 处理；resolvePromise 函数递归解析返回值 x，避免循环引用并正确处理 thenable 对象；最后补充 resolve、reject、catch、finally 等常用方法以增强实用性。

实现一个符合 Promise A+ 规范的 Promise 类，核心在于理解其状态机制、异步解析流程以及 then 方法的处理规则。下面是一个简化但符合规范关键点的实现，帮助你掌握原理。

1. 状态定义与基本结构

Promise 有三种状态：pending（等待）、fulfilled（成功）、rejected（失败）。状态一旦改变，不可逆。

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 (error) {
    reject(error);
  }
}

2. 实现 then 方法

then 方法必须返回一个新的 Promise，实现链式调用。这是 Promise A+ 的核心要求之一。

MyPromise.prototype.then = function(onFulfilled, onRejected) {
  // 处理穿透，比如 .then().then(value => ...)
  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;
};

3. 处理返回值 x（resolvePromise）

这个函数是 Promise A+ 规范中最复杂的部分，用于处理 then 回调返回的值 x，决定如何解析新 Promise。

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

  let called = false;

  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);
  }
}

4. 补充常用方法（可选）

虽然不是 A+ 规范强制要求，但可以添加一些静态方法增强实用性。

MyPromise.resolve = function(value) {
  return new MyPromise(resolve => resolve(value));
};

MyPromise.reject = function(reason) {
  return new MyPromise((resolve, reject) => reject(reason));
};

MyPromise.prototype.catch = function(onRejected) {
  return this.then(null, onRejected);
};

MyPromise.prototype.finally = function(callback) {
  return this.then(
    value => MyPromise.resolve(callback()).then(() => value),
    reason => MyPromise.resolve(callback()).then(() => { throw reason; })
  );
};

基本上就这些。这个实现覆盖了 Promise A+ 的主要逻辑：状态管理、异步任务队列、then 链式调用和 resolvePromise 的递归解析。要完全通过官方测试套件（promises-aplus-tests），还需更严格的边界处理，但上述代码已能体现核心思想。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《实现PromiseA+规范的完整指南》文章吧，也可关注golang学习网公众号了解相关技术文章。