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

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

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

解决方案

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

1. 状态（States）： Promise 必须有三种状态：

   pending

   （进行中）、

   fulfilled

   （已成功）和

   rejected

   （已失败）。状态一旦改变，就不能再次改变。

2. then

   方法：

   then

   方法用于注册当 Promise 状态改变时要执行的回调函数。它可以被多次调用，并且必须返回一个新的 Promise。

3. 解决过程（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 #'))
  }

  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 的异常处理主要依赖于

reject

then

onRejected

executor

onFulfilled

rejected

onRejected

onRejected

onRejected

此外，可以使用

catch

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 时需要考虑的重要因素。以下是一些常见的优化策略：

千问APP

阿里最强大模型官方AI助手

下载

1. 避免不必要的异步操作： 如果 Promise 的结果已经可用，可以直接同步地调用

   onFulfilled

   或

   onRejected

   回调，而不需要使用

   setTimeout

   或其他异步机制。

2. 减少 Promise 的创建： 频繁地创建 Promise 会增加内存消耗和垃圾回收的压力。尽量重用 Promise 实例，避免在循环或高频调用的函数中创建 Promise。

3. 使用微任务队列： 使用

   MutationObserver

   或

   process.nextTick

   等微任务队列来调度回调函数，可以比

   setTimeout

   更快地执行回调，提高 Promise 的响应速度。但要注意，过度使用微任务队列可能会导致 UI 渲染阻塞。

4. 避免深层 Promise 嵌套： 深层 Promise 嵌套会增加代码的复杂性和调试难度，并且可能导致性能问题。尽量使用

   async/await

   语法糖来简化异步代码，减少 Promise 的嵌套。

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

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

1. 安装测试套件： 使用 npm 安装

   promises-aplus-tests

   包。

   npm install promises-aplus-tests --save-dev

2. 编写测试适配器： 创建一个测试适配器，将手写的 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
   };

3. 运行测试： 使用

   promises-aplus-tests

   命令运行测试，并指定测试适配器。

   npx promises-aplus-tests adapter.js

   测试套件会运行所有测试用例，并输出测试结果。如果所有测试都通过，则说明手写的 Promise 符合 Promises/A+ 规范。

请注意，这只是一个简化的实现，实际的 Promise 实现需要考虑更多的细节和边界情况，例如处理 Promise 的循环引用、处理

then