JSPromise原理分析与实现教程

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《JS Promise 原理详解与手写实现》，这篇文章主要讲到等等知识，如果你对文章相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

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 链的正确执行。

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

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 方法的返回值等。建议参考 Promises/A+ 规范和成熟的 Promise 库（例如 Bluebird）的源码，以获得更完整的理解。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。