JS Promise 实现原理 - 手写符合 Promises/A+ 规范的异步解决方案-js教程-PHP中文网

JS Promise 实现原理 - 手写符合 Promises/A+ 规范的异步解决方案

幻影之瞳

发布： 2025-09-17 22:16:01

原创

494人浏览过

Promise通过状态机解决异步编程中的回调地狱问题，其核心是实现pending、fulfilled、rejected三种状态的不可逆转换及then方法链式调用；需遵循Promises/A+规范，重点处理resolvePromise过程以支持嵌套与异常捕获，并通过官方测试套件验证兼容性。

js promise 实现原理 - 手写符合 promises/a+ 规范的异步解决方案

Promise 的核心在于解决 JavaScript 异步编程中的回调地狱问题，并提供更优雅的错误处理机制。本质上，Promise 是一种状态机，它代表了一个异步操作的最终完成（或失败）及其结果值。手写 Promise 意味着要理解并实现这种状态转换和结果传递的机制。

解决方案

实现一个符合 Promises/A+ 规范的 Promise，需要关注以下几个关键点：

状态（States）： Promise 必须有三种状态：
```
pending
```
登录后复制
（进行中）、
```
fulfilled
```
登录后复制
（已成功）和
```
rejected
```
登录后复制
（已失败）。状态一旦改变，就不能再次改变。
```
then
```
登录后复制
方法：
```
then
```
登录后复制
方法用于注册当 Promise 状态改变时要执行的回调函数。它可以被多次调用，并且必须返回一个新的 Promise。
解决过程（Resolution Procedure）： 这是 Promise 实现中最复杂的部分，它定义了如何将 Promise 的状态从
```
pending
```
登录后复制
转换为
```
fulfilled
```
登录后复制
或
```
rejected
```
登录后复制
。特别需要处理
```
then
```
登录后复制
方法返回的 Promise 的解决，以及 Promise 链中的异常捕获。

一个简单的 Promise 实现的骨架如下：

function MyPromise(executor) {
  let state = 'pending';
  let value = undefined;
  let reason = undefined;
  let onFulfilledCallbacks = [];
  let onRejectedCallbacks = [];

  function resolve(val) {
    if (state === 'pending') {
      state = 'fulfilled';
      value = val;
      onFulfilledCallbacks.forEach(callback => callback(value));
    }
  }

  function reject(rea) {
    if (state === 'pending') {
      state = 'rejected';
      reason = rea;
      onRejectedCallbacks.forEach(callback => callback(reason));
    }
  }

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

  this.then = function(onFulfilled, onRejected) {
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
    onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason };

    let promise2 = new MyPromise((resolve, reject) => {
      if (state === 'fulfilled') {
        setTimeout(() => { // 确保 promise2 已经被创建
          try {
            let x = onFulfilled(value);
            resolvePromise(promise2, x, resolve, reject);
          } catch (e) {
            reject(e);
          }
        }, 0);
      }

      if (state === 'rejected') {
        setTimeout(() => {
          try {
            let x = onRejected(reason);
            resolvePromise(promise2, x, resolve, reject);
          } catch (e) {
            reject(e);
          }
        }, 0);
      }

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

        onRejectedCallbacks.push(() => {
          setTimeout(() => {
            try {
              let x = onRejected(reason);
              resolvePromise(promise2, x, resolve, reject);
            } catch (e) {
              reject(e);
            }
          }, 0);
        });
      }
    });

    return promise2;
  }
}

function resolvePromise(promise2, x, resolve, reject) {
  if (promise2 === x) {
    return reject(new TypeError('Chaining cycle detected for promise #<MyPromise>'))
  }

  let called;
  if ((typeof x === 'object' && x != null) || typeof x === 'function') {
    try {
      let 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 实现，包括状态管理、

then

登录后复制

方法和异步执行。

resolvePromise

登录后复制

函数是解决过程的核心，它递归地处理 Promise 的嵌套，确保 Promise 链的正确执行。

如何处理 Promise 中的异常？

Promise 的异常处理主要依赖于

reject

登录后复制

函数和

then

登录后复制

方法的第二个参数（

onRejected

登录后复制

）。如果在

executor

登录后复制

函数或

onFulfilled

登录后复制

回调中抛出异常，Promise 的状态会变为

rejected

登录后复制

，并且异常会被传递给

onRejected

登录后复制

回调。如果没有提供

onRejected

登录后复制

回调，异常会被传递到 Promise 链的下一个

onRejected

登录后复制

回调，直到被捕获。

此外，可以使用

catch

登录后复制

方法来捕获 Promise 链中的所有异常。

catch

登录后复制

方法实际上是

then(null, onRejected)

登录后复制

的语法糖。

new MyPromise((resolve, reject) => {
  throw new Error('Something went wrong!');
})
.then(() => {
  // This will not be executed
})
.catch(error => {
  console.error('Caught an error:', error); // Output: Caught an error: Error: Something went wrong!
});

登录后复制

手写 Promise 时需要注意哪些性能优化？

性能优化是手写 Promise 时需要考虑的重要因素。以下是一些常见的优化策略：

智写助手

智写助手写得更快，更聪明

查看详情

避免不必要的异步操作： 如果 Promise 的结果已经可用，可以直接同步地调用
```
onFulfilled
```
登录后复制
或
```
onRejected
```
登录后复制
回调，而不需要使用
```
setTimeout
```
登录后复制
或其他异步机制。
减少 Promise 的创建： 频繁地创建 Promise 会增加内存消耗和垃圾回收的压力。尽量重用 Promise 实例，避免在循环或高频调用的函数中创建 Promise。
使用微任务队列： 使用
```
MutationObserver
```
登录后复制
或
```
process.nextTick
```
登录后复制
等微任务队列来调度回调函数，可以比
```
setTimeout
```
登录后复制
更快地执行回调，提高 Promise 的响应速度。但要注意，过度使用微任务队列可能会导致 UI 渲染阻塞。
避免深层 Promise 嵌套： 深层 Promise 嵌套会增加代码的复杂性和调试难度，并且可能导致性能问题。尽量使用
```
async/await
```
登录后复制
语法糖来简化异步代码，减少 Promise 的嵌套。

如何测试手写的 Promise 是否符合 Promises/A+ 规范？

要确保手写的 Promise 符合 Promises/A+ 规范，可以使用 Promises/A+ 官方提供的测试套件。该测试套件包含一系列测试用例，可以验证 Promise 的行为是否符合规范。

安装测试套件： 使用 npm 安装
```
promises-aplus-tests
```
登录后复制
包。
```
npm install promises-aplus-tests --save-dev
```
登录后复制

编写测试适配器： 创建一个测试适配器，将手写的 Promise 暴露给测试套件。

// adapter.js
const MyPromise = require('./my-promise'); // 替换为你的 Promise 实现

module.exports = {
  deferred: function() {
    let dfd = {};
    dfd.promise = new MyPromise((resolve, reject) => {
      dfd.resolve = resolve;
      dfd.reject = reject;
    });
    return dfd;
  },
  resolved: MyPromise.resolve,
  rejected: MyPromise.reject
};

登录后复制

运行测试： 使用
```
promises-aplus-tests
```
登录后复制
命令运行测试，并指定测试适配器。
```
npx promises-aplus-tests adapter.js
```
登录后复制
测试套件会运行所有测试用例，并输出测试结果。如果所有测试都通过，则说明手写的 Promise 符合 Promises/A+ 规范。