Promise通过状态机解决异步编程中的回调地狱问题，其核心是实现pending、fulfilled、rejected三种状态的不可逆转换及then方法链式调用；需遵循Promises/A+规范，重点处理resolvePromise过程以支持嵌套与异常捕获，并通过官方测试套件验证兼容性。
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 #')) } 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.jsconst 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+ 规范。
请注意，这只是一个简化的实现，实际的 Promise 实现需要考虑更多的细节和边界情况，例如处理 Promise 的循环引用、处理
then
方法的返回值等。建议参考 Promises/A+ 规范和成熟的 Promise 库（例如 Bluebird）的源码，以获得更完整的理解。
以上就是JS Promise 实现原理 – 手写符合 Promises/A+ 规范的异步解决方案的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/67380.html
微信扫一扫 
支付宝扫一扫 
