devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

原以为很简单，结果这道 Promise 面试题让我失眠好一会

作者：木道寻08 | 2024-07-24 20:02:15

赞

踩

.then(() => { console.log(1); }).then(() => { console.log(2);

先把罪魁祸首挂在这里给大家群殴 ????

  1. Promise.resolve().then(() => {
  2.     console.log(0);
  3.     return Promise.resolve(4);
  4. }).then((res) => {
  5.     console.log(res)
  6. })
  7.  
  8. Promise.resolve().then(() => {
  9.     console.log(1);
  10. }).then(() => {
  11.     console.log(2);
  12. }).then(() => {
  13.     console.log(3);
  14. }).then(() => {
  15.     console.log(5);
  16. }).then(() =>{
  17.     console.log(6);
  18. })
  19.  
  20. // 大家先思考一下

这道面试题是无意间在微信群里看到的，据说是某厂的面试题。一般关于 Promise 的面试题无非是考察宏微任务、EventLoop 之类的，当我认真去分析这道题的时候，越看越不对劲，感觉有诈！这是要考察啥？

不管了，先在浏览器输出一下看看 ????

打印结果：0、1、2、3、4、5、6 ????

这里4怎么跑到3后面去了，不讲武德？ Why......

在我看来，这道题有两个 Promise.resolve()，相当于创建两个状态为 fulfilled 的 Promise。

紧随他们后面的第一个 then 方法会交替将其执行函数送入微任务队列排队执行，所以这里的0和1，大家都可以理解，但是接下来执行的不是 console.log(res) 而是 console.log(2)。

如果说需要等待 return Promise.resolve(4) 执行完并将其结果和状态同步给外部的 Promise，那么这里只需要创建一个微任务去处理就应该可以了，也就是 4 会在 2 后面才对，为啥需要创建两个微任务呢？ ????

想了很久，也找很多朋友讨论这个问题，都没有得到有说服力的结论，真是百思不得其解！这样死抠细节，感觉有点浪费时间，毕竟这种面试题在生产中并不会出现，谁会去写这么奇葩的 Promise 代码， 放弃了，不去想了。

然而????，当天晚上夜黑风高夜深人静的时候，脑海里面依然轮播这道面试题，真的很想知道 Promise 内部到底是个什么逻辑，越想越睡不着～越睡不着越想~


无奈之下，决定参考 Promise A+ 规范手写一版 Promise，看看能不能从实现细节中找到蛛丝马迹。为了方便大家理解，下面我会利用不同 ???? 来介绍手写的细节和思路。文章最后会依据实现细节来探讨这道面试题，有手写经验的可以直接跳过手写 Promise 实现过程，看最后的结论。

手写前需要先了解这些

如果感觉对 Promise 还不太熟悉的就先移步 Promise 入门，稍微做一下知识预习，了解一下 Promise 的常规用法。

什么是宏任务与微任务？

我们都知道 Js 是单线程都，但是一些高耗时操作就带来了进程阻塞问题。为了解决这个问题，Js 有两种任务的执行模式：同步模式（Synchronous）和异步模式（Asynchronous）。

在异步模式下，创建异步任务主要分为宏任务与微任务两种。ES6 规范中，宏任务（Macrotask） 称为 Task， 微任务（Microtask） 称为 Jobs。宏任务是由宿主（浏览器、Node）发起的，而微任务由 JS 自身发起。

宏任务与微任务的几种创建方式 ????

宏任务（Macrotask）微任务（Microtask）
setTimeoutrequestAnimationFrame（有争议）
setIntervalMutationObserver（浏览器环境）
MessageChannelPromise.[ then/catch/finally ]
I/O，事件队列process.nextTick（Node环境）
setImmediate（Node环境）queueMicrotask
script（整体代码块）

如何理解 script（整体代码块）是个宏任务呢 ????

实际上如果同时存在两个 script 代码块，会首先在执行第一个 script 代码块中的同步代码，如果这个过程中创建了微任务并进入了微任务队列，第一个 script 同步代码执行完之后，会首先去清空微任务队列，再去开启第二个 script 代码块的执行。所以这里应该就可以理解 script（整体代码块）为什么会是宏任务。

什么是 EventLoop ？

先来看个图

EventLoop.png

  1. 判断宏任务队列是否为空

  • 不空 --> 执行最早进入队列的任务 --> 执行下一步

  • 空 --> 执行下一步

  • 判断微任务队列是否为空

    • 不空 --> 执行最早进入队列的任务 --> 继续检查微任务队列空不空

    • 空 --> 执行下一步

    因为首次执行宏队列中会有 script（整体代码块）任务，所以实际上就是 Js 解析完成后，在异步任务中，会先执行完所有的微任务，这里也是很多面试题喜欢考察的。需要注意的是，新创建的微任务会立即进入微任务队列排队执行，不需要等待下一次轮回。

    什么是 Promise A+ 规范？

    看到 A+ 肯定会想到是不是还有 A，事实上确实有。其实 Promise 有多种规范，除了前面的 Promise A、promise A+ 还有 Promise/B，Promise/D。目前我们使用的 Promise 是基于 Promise A+ 规范实现的，感兴趣的移步 Promise A+规范了解一下，这里不赘述。

    检验一份手写 Promise 靠不靠谱，通过 Promise A+ 规范自然是基本要求，这里我们可以借助 promises-aplus-tests 来检测我们的代码是否符合规范，后面我会讲到如何使用它。

    手写开始

    很多手写版本都是使用 setTimeout 去做异步处理，但是 setTimeout 属于宏任务，这与 Promise 是个微任务相矛盾，所以我打算选择一种创建微任务的方式去实现我们的手写代码。

    这里我们有几种选择，一种就是 Promise A+ 规范中也提到的，process.nextTick（ Node 端 ） 与MutationObserver（ 浏览器端 ），考虑到利用这两种方式需要做环境判断，所以在这里我们就推荐另外一种创建微任务的方式 queueMicrotask，了解更多 --> 在 JavaScript 中通过 queueMicrotask() 使用微任务;

    一、Promise 核心逻辑实现

    我们先简单实现一下 Promise 的基础功能。先看原生 Promise 实现的 ????，第一步我们要完成相同的功能。

    原生???? ????

    1. const promise = new Promise((resolve, reject) => {
    2.    resolve( success )
    3.    reject( err )
    4. })
    5.  
    6. promise.then(value => {
    7.   console.log( resolve , value)
    8. }, reason => {
    9.   console.log( reject , reason)
    10. })
    11.  
    12. // 输出 resolve success
    13.

    我们来分析一下基本原理：

    1. Promise 是一个类，在执行这个类的时候会传入一个执行器，这个执行器会立即执行

    2. Promise 会有三种状态

    • Pending 等待

    • Fulfilled 完成

    • Rejected 失败

    • 状态只能由 Pending --> Fulfilled 或者 Pending --> Rejected，且一但发生改变便不可二次修改；

    • Promise 中使用 resolve 和 reject 两个函数来更改状态；

    • then 方法内部做但事情就是状态判断

      • 如果状态是成功，调用成功回调函数

      • 如果状态是失败，调用失败回调函数

    下面开始实现：

    1. 新建 MyPromise 类，传入执行器 executor
    1. // 新建 MyPromise.js
    2.  
    3. // 新建 MyPromise 类
    4. class MyPromise {
    5.   constructor(executor){
    6.     // executor 是一个执行器，进入会立即执行
    7.     executor() 
    8.   }
    9. }
    10.
    2. executor 传入 resolve 和 reject 方法
    1. // MyPromise.js
    2.  
    3. // 新建 MyPromise 类
    4. class MyPromise {
    5.   constructor(executor){
    6.     // executor 是一个执行器，进入会立即执行
    7.     // 并传入resolve和reject方法
    8.     executor(this.resolve, this.reject) 
    9.   }
    10.   // resolve和reject为什么要用箭头函数？
    11.   // 如果直接调用的话，普通函数this指向的是window或者undefined
    12.   // 用箭头函数就可以让this指向当前实例对象
    13.   // 更改成功后的状态
    14.   resolve = () => {}
    15.   // 更改失败后的状态
    16.   reject = () => {}
    17. }
    18.
    3. 状态与结果的管理
    1. // MyPromise.js
    2.  
    3. // 先定义三个常量表示状态
    4. const PENDING =  pending ;
    5. const FULFILLED =  fulfilled ;
    6. const REJECTED =  rejected ;
    7.  
    8. // 新建 MyPromise 类
    9. class MyPromise {
    10.   constructor(executor){
    11.     // executor 是一个执行器，进入会立即执行
    12.     // 并传入resolve和reject方法
    13.     executor(this.resolve, this.reject)
    14.   }
    15.  
    16.   // 储存状态的变量，初始值是 pending
    17.   status = PENDING;
    18.  
    19.   // resolve和reject为什么要用箭头函数？
    20.   // 如果直接调用的话，普通函数this指向的是window或者undefined
    21.   // 用箭头函数就可以让this指向当前实例对象
    22.   // 成功之后的值
    23.   value = null;
    24.   // 失败之后的原因
    25.   reason = null;
    26.  
    27.   // 更改成功后的状态
    28.   resolve = (value) => {
    29.     // 只有状态是等待，才执行状态修改
    30.     if (this.status === PENDING) {
    31.       // 状态修改为成功
    32.       this.status = FULFILLED;
    33.       // 保存成功之后的值
    34.       this.value = value;
    35.     }
    36.   }
    37.  
    38.   // 更改失败后的状态
    39.   reject = (reason) => {
    40.     // 只有状态是等待，才执行状态修改
    41.     if (this.status === PENDING) {
    42.       // 状态成功为失败
    43.       this.status = REJECTED;
    44.       // 保存失败后的原因
    45.       this.reason = reason;
    46.     }
    47.   }
    48. }
    49.  
    50.
    4. then 的简单实现
    1. // MyPromise.js
    2.  
    3. then(onFulfilled, onRejected) {
    4.   // 判断状态
    5.   if (this.status === FULFILLED) {
    6.     // 调用成功回调，并且把值返回
    7.     onFulfilled(this.value);
    8.   } else if (this.status === REJECTED) {
    9.     // 调用失败回调，并且把原因返回
    10.     onRejected(this.reason);
    11.   }
    12. }
    13.
    5. 使用 module.exports 对外暴露 MyPromise 类
    1. // MyPromise.js
    2. module.exports = MyPromise;
    3.

    看一下我们目前实现的完整代码????

    1. // MyPromise.js
    2.  
    3. // 先定义三个常量表示状态
    4. const PENDING =  pending ;
    5. const FULFILLED =  fulfilled ;
    6. const REJECTED =  rejected ;
    7.  
    8. // 新建 MyPromise 类
    9. class MyPromise {
    10.   constructor(executor){
    11.     // executor 是一个执行器，进入会立即执行
    12.     // 并传入resolve和reject方法
    13.     executor(this.resolve, this.reject)
    14.   }
    15.  
    16.   // 储存状态的变量，初始值是 pending
    17.   status = PENDING;
    18.  
    19.   // resolve和reject为什么要用箭头函数？
    20.   // 如果直接调用的话，普通函数this指向的是window或者undefined
    21.   // 用箭头函数就可以让this指向当前实例对象
    22.   // 成功之后的值
    23.   value = null;
    24.   // 失败之后的原因
    25.   reason = null;
    26.  
    27.   // 更改成功后的状态
    28.   resolve = (value) => {
    29.     // 只有状态是等待，才执行状态修改
    30.     if (this.status === PENDING) {
    31.       // 状态修改为成功
    32.       this.status = FULFILLED;
    33.       // 保存成功之后的值
    34.       this.value = value;
    35.     }
    36.   }
    37.  
    38.   // 更改失败后的状态
    39.   reject = (reason) => {
    40.     // 只有状态是等待，才执行状态修改
    41.     if (this.status === PENDING) {
    42.       // 状态成功为失败
    43.       this.status = REJECTED;
    44.       // 保存失败后的原因
    45.       this.reason = reason;
    46.     }
    47.   }
    48.  
    49.   then(onFulfilled, onRejected) {
    50.     // 判断状态
    51.     if (this.status === FULFILLED) {
    52.       // 调用成功回调，并且把值返回
    53.       onFulfilled(this.value);
    54.     } else if (this.status === REJECTED) {
    55.       // 调用失败回调，并且把原因返回
    56.       onRejected(this.reason);
    57.     }
    58.   }
    59. }
    60.  
    61. module.exports = MyPromise
    62.

    使用我的手写代码执行一下上面那个????

    1. // 新建 test.js
    2.  
    3. // 引入我们的 MyPromise.js
    4. const MyPromise = require( ./MyPromise )
    5. const promise = new MyPromise((resolve, reject) => {
    6.    resolve( success )
    7.    reject( err )
    8. })
    9.  
    10. promise.then(value => {
    11.   console.log( resolve , value)
    12. }, reason => {
    13.   console.log( reject , reason)
    14. })
    15.  
    16. // 执行结果：resolve success
    17.

    执行结果符合我们的预期，第一步完成了????????????

    二、在 Promise 类中加入异步逻辑

    上面还没有经过异步处理，如果有异步逻辑加如来会带来一些问题，例如：

    1. // test.js
    2.  
    3. const MyPromise = require( ./MyPromise )
    4. const promise = new MyPromise((resolve, reject) => {
    5.   setTimeout(() => {
    6.     resolve( success )
    7.   }, 2000); 
    8. })
    9.  
    10. promise.then(value => {
    11.   console.log( resolve , value)
    12. }, reason => {
    13.   console.log( reject , reason)
    14. })
    15.  
    16. // 没有打印信息！！！
    17.

    分析原因：

    主线程代码立即执行，setTimeout 是异步代码，then 会马上执行，这个时候判断 Promise 状态，状态是 Pending，然而之前并没有判断等待这个状态

    这里就需要我们处理一下 Pending 状态，我们改造一下之前的代码 ????

    1. 缓存成功与失败回调
    1. // MyPromise.js
    2.  
    3. // MyPromise 类中新增
    4. // 存储成功回调函数
    5. onFulfilledCallback = null;
    6. // 存储失败回调函数
    7. onRejectedCallback = null;
    8.
    2. then 方法中的 Pending 的处理
    1. // MyPromise.js
    2.  
    3. then(onFulfilled, onRejected) {
    4.   // 判断状态
    5.   if (this.status === FULFILLED) {
    6.     // 调用成功回调，并且把值返回
    7.     onFulfilled(this.value);
    8.   } else if (this.status === REJECTED) {
    9.     // 调用失败回调，并且把原因返回
    10.     onRejected(this.reason);
    11.   } else if (this.status === PENDING) {
    12.     // ==== 新增 ====
    13.     // 因为不知道后面状态的变化情况，所以将成功回调和失败回调存储起来
    14.     // 等到执行成功失败函数的时候再传递
    15.     this.onFulfilledCallback = onFulfilled;
    16.     this.onRejectedCallback = onRejected;
    17.   }
    18. }
    19.
    3. resolve 与 reject 中调用回调函数
    1. // MyPromise.js
    2.  
    3. // 更改成功后的状态
    4. resolve = (value) => {
    5.   // 只有状态是等待，才执行状态修改
    6.   if (this.status === PENDING) {
    7.     // 状态修改为成功
    8.     this.status = FULFILLED;
    9.     // 保存成功之后的值
    10.     this.value = value;
    11.     // ==== 新增 ====
    12.     // 判断成功回调是否存在，如果存在就调用
    13.     this.onFulfilledCallback && this.onFulfilledCallback(value);
    14.   }
    15. }
    16.  
    1. // MyPromise.js
    2. // 更改失败后的状态
    3. reject = (reason) => {
    4.   // 只有状态是等待，才执行状态修改
    5.   if (this.status === PENDING) {
    6.     // 状态成功为失败
    7.     this.status = REJECTED;
    8.     // 保存失败后的原因
    9.     this.reason = reason;
    10.     // ==== 新增 ====
    11.     // 判断失败回调是否存在，如果存在就调用
    12.     this.onRejectedCallback && this.onRejectedCallback(reason)
    13.   }
    14. }
    15.

    我们再执行一下上面的????

    1. // test.js
    2.  
    3. const MyPromise = require( ./MyPromise )
    4. const promise = new MyPromise((resolve, reject) => {
    5.   setTimeout(() => {
    6.     resolve( success )
    7.   }, 2000); 
    8. })
    9.  
    10. promise.then(value => {
    11.   console.log( resolve , value)
    12. }, reason => {
    13.   console.log( reject , reason)
    14. })
    15.  
    16. // 等待 2s 输出 resolve success
    17.

    目前已经可以简单处理异步问题了✌️

    三、实现 then 方法多次调用添加多个处理函数

    Promise 的 then 方法是可以被多次调用的。这里如果有三个 then 的调用，如果是同步回调，那么直接返回当前的值就行；如果是异步回调，那么保存的成功失败的回调，需要用不同的值保存，因为都互不相同。之前的代码需要改进。

    同样的先看一个????

    1. // test.js
    2.  
    3. const MyPromise = require( ./MyPromise )
    4. const promise = new MyPromise((resolve, reject) => {
    5.   setTimeout(() => {
    6.     resolve( success )
    7.   }, 2000); 
    8. })
    9.  
    10. promise.then(value => {
    11.   console.log(1)
    12.   console.log( resolve , value)
    13. })
    14.  
    15. promise.then(value => {
    16.   console.log(2)
    17.   console.log( resolve , value)
    18. })
    19.  
    20. promise.then(value => {
    21.   console.log(3)
    22.   console.log( resolve , value)
    23. })
    24.  
    25. // 3
    26. // resolve success
    27.  
    28.

    目前的代码只能输出：3 resolve success，怎么可以把 1、2 弄丢呢！

    我们应该一视同仁，保证所有 then 中的回调函数都可以执行 ???? 继续改造

    1. MyPromise 类中新增两个数组
    1. // MyPromise.js
    2.  
    3. // 存储成功回调函数
    4. // onFulfilledCallback = null;
    5. onFulfilledCallbacks = [];
    6. // 存储失败回调函数
    7. // onRejectedCallback = null;
    8. onRejectedCallbacks = [];
    9.
    2. 回调函数存入数组中
    1. // MyPromise.js
    2.  
    3. then(onFulfilled, onRejected) {
    4.   // 判断状态
    5.   if (this.status === FULFILLED) {
    6.     // 调用成功回调，并且把值返回
    7.     onFulfilled(this.value);
    8.   } else if (this.status === REJECTED) {
    9.     // 调用失败回调，并且把原因返回
    10.     onRejected(this.reason);
    11.   } else if (this.status === PENDING) {
    12.     // ==== 新增 ====
    13.     // 因为不知道后面状态的变化，这里先将成功回调和失败回调存储起来
    14.     // 等待后续调用
    15.     this.onFulfilledCallbacks.push(onFulfilled);
    16.     this.onRejectedCallbacks.push(onRejected);
    17.   }
    18. }
    19.
    3. 循环调用成功和失败回调
    1. // MyPromise.js
    2.  
    3. // 更改成功后的状态
    4. resolve = (value) => {
    5.   // 只有状态是等待，才执行状态修改
    6.   if (this.status === PENDING) {
    7.     // 状态修改为成功
    8.     this.status = FULFILLED;
    9.     // 保存成功之后的值
    10.     this.value = value;
    11.     // ==== 新增 ====
    12.     // resolve里面将所有成功的回调拿出来执行
    13.     while (this.onFulfilledCallbacks.length) {
    14.       // Array.shift() 取出数组第一个元素，然后（）调用，shift不是纯函数，取出后，数组将失去该元素，直到数组为空
    15.       this.onFulfilledCallbacks.shift()(value)
    16.     }
    17.   }
    18. }
    19.  
    1. // MyPromise.js
    2.  
    3. // 更改失败后的状态
    4. reject = (reason) => {
    5.   // 只有状态是等待，才执行状态修改
    6.   if (this.status === PENDING) {
    7.     // 状态成功为失败
    8.     this.status = REJECTED;
    9.     // 保存失败后的原因
    10.     this.reason = reason;
    11.     // ==== 新增 ====
    12.     // resolve里面将所有失败的回调拿出来执行
    13.     while (this.onRejectedCallbacks.length) {
    14.       this.onRejectedCallbacks.shift()(reason)
    15.     }
    16.   }
    17. }
    18.

    再来运行一下，看看结果????

    1. 1
    2. resolve success
    3. 2
    4. resolve success
    5. 3
    6. resolve success
    7.

    ???????????? 完美，继续

    四、实现 then 方法的链式调用

    then 方法要链式调用那么就需要返回一个 Promise 对象
    then 方法里面 return 一个返回值作为下一个 then 方法的参数，如果是 return 一个 Promise 对象，那么就需要判断它的状态

    举个栗子 ????

    1. // test.js
    2.  
    3. const MyPromise = require( ./MyPromise )
    4. const promise = new MyPromise((resolve, reject) => {
    5.   // 目前这里只处理同步的问题
    6.   resolve( success )
    7. })
    8.  
    9. function other () {
    10.   return new MyPromise((resolve, reject) =>{
    11.     resolve( other )
    12.   })
    13. }
    14. promise.then(value => {
    15.   console.log(1)
    16.   console.log( resolve , value)
    17.   return other()
    18. }).then(value => {
    19.   console.log(2)
    20.   console.log( resolve , value)
    21. })
    22.

    用目前的手写代码运行的时候会报错 ???? 无法链式调用

    1. }).then(value => {
    2.   ^
    3.  
    4. TypeError: Cannot read property  then  of undefined
    5.

    接着改 ????

    1. // MyPromise.js
    2.  
    3. class MyPromise {
    4.   ......
    5.   then(onFulfilled, onRejected) {
    6.     // ==== 新增 ====
    7.     // 为了链式调用这里直接创建一个 MyPromise，并在后面 return 出去
    8.     const promise2 = new MyPromise((resolve, reject) => {
    9.       // 这里的内容在执行器中，会立即执行
    10.       if (this.status === FULFILLED) {
    11.         // 获取成功回调函数的执行结果
    12.         const x = onFulfilled(this.value);
    13.         // 传入 resolvePromise 集中处理
    14.         resolvePromise(x, resolve, reject);
    15.       } else if (this.status === REJECTED) {
    16.         onRejected(this.reason);
    17.       } else if (this.status === PENDING) {
    18.         this.onFulfilledCallbacks.push(onFulfilled);
    19.         this.onRejectedCallbacks.push(onRejected);
    20.       }
    21.     }) 
    22.     
    23.     return promise2;
    24.   }
    25. }
    26.  
    27. function resolvePromise(x, resolve, reject) {
    28.   // 判断x是不是 MyPromise 实例对象
    29.   if(x instanceof MyPromise) {
    30.     // 执行 x，调用 then 方法，目的是将其状态变为 fulfilled 或者 rejected
    31.     // x.then(value => resolve(value), reason => reject(reason))
    32.     // 简化之后
    33.     x.then(resolve, reject)
    34.   } else{
    35.     // 普通值
    36.     resolve(x)
    37.   }
    38. }
    39.

    执行一下，结果????

    1. 1
    2. resolve success
    3. 2
    4. resolve other
    5.

    em... 符合预期 ????

    五、then 方法链式调用识别 Promise 是否返回自己

    如果 then 方法返回的是自己的 Promise 对象，则会发生循环调用，这个时候程序会报错

    例如下面这种情况????

    1. // test.js
    2.  
    3. const promise = new Promise((resolve, reject) => {
    4.   resolve(100)
    5. })
    6. const p1 = promise.then(value => {
    7.   console.log(value)
    8.   return p1
    9. })
    10.

    使用原生 Promise 执行这个代码，会报类型错误

    1. 100
    2. Uncaught (in promise) TypeError: Chaining cycle detected for promise #<Promise>
    3.

    我们在 MyPromise 实现一下

    1. // MyPromise.js
    2.  
    3. class MyPromise {
    4.   ......
    5.   then(onFulfilled, onRejected) {
    6.     const promise2 = new MyPromise((resolve, reject) => {
    7.       if (this.status === FULFILLED) {
    8.         const x = onFulfilled(this.value);
    9.         // resolvePromise 集中处理，将 promise2 传入
    10.         resolvePromise(promise2, x, resolve, reject);
    11.       } else if (this.status === REJECTED) {
    12.         onRejected(this.reason);
    13.       } else if (this.status === PENDING) {
    14.         this.onFulfilledCallbacks.push(onFulfilled);
    15.         this.onRejectedCallbacks.push(onRejected);
    16.       }
    17.     }) 
    18.     
    19.     return promise2;
    20.   }
    21. }
    22.  
    23. function resolvePromise(promise2, x, resolve, reject) {
    24.   // 如果相等了，说明return的是自己，抛出类型错误并返回
    25.   if (promise2 === x) {
    26.     return reject(new TypeError( Chaining cycle detected for promise #<Promise> ))
    27.   }
    28.   if(x instanceof MyPromise) {
    29.     x.then(resolve, reject)
    30.   } else{
    31.     resolve(x)
    32.   }
    33. }
    34.

    执行一下，竟然报错了 ????

    1.         resolvePromise(promise2, x, resolve, reject);
    2.                        ^
    3.  
    4. ReferenceError: Cannot access  promise2  before initialization
    5.

    为啥会报错呢？从错误提示可以看出，我们必须要等 promise2 完成初始化。这个时候我们就要用上宏微任务和事件循环的知识了，这里就需要创建一个异步函数去等待 promise2 完成初始化，前面我们已经确认了创建微任务的技术方案 --> queueMicrotask

    1. // MyPromise.js
    2.  
    3. class MyPromise {
    4.   ......
    5.   then(onFulfilled, onRejected) {
    6.     const promise2 = new MyPromise((resolve, reject) => {
    7.       if (this.status === FULFILLED) {
    8.         // ==== 新增 ====
    9.         // 创建一个微任务等待 promise2 完成初始化
    10.         queueMicrotask(() => {
    11.           // 获取成功回调函数的执行结果
    12.           const x = onFulfilled(this.value);
    13.           // 传入 resolvePromise 集中处理
    14.           resolvePromise(promise2, x, resolve, reject);
    15.         })  
    16.       } else if (this.status === REJECTED) {
    17.       ......
    18.     }) 
    19.     
    20.     return promise2;
    21.   }
    22. }
    23.

    执行一下

    1. // test.js
    2.  
    3. const MyPromise = require( ./MyPromise )
    4. const promise = new MyPromise((resolve, reject) => {
    5.     resolve( success )
    6. })
    7.  
    8. // 这个时候将promise定义一个p1，然后返回的时候返回p1这个promise
    9. const p1 = promise.then(value => {
    10.    console.log(1)
    11.    console.log( resolve , value)
    12.    return p1
    13. })
    14.  
    15. // 运行的时候会走reject
    16. p1.then(value => {
    17.   console.log(2)
    18.   console.log( resolve , value)
    19. }, reason => {
    20.   console.log(3)
    21.   console.log(reason.message)
    22. })
    23.

    这里得到我们的结果 ????

    1. 1
    2. resolve success
    3. 3
    4. Chaining cycle detected for promise #<Promise>
    5.

    哈哈，搞定 ???? 开始下一步

    六、捕获错误及 then 链式调用其他状态代码补充

    目前还缺少重要的一个环节，就是我们的错误捕获还没有处理

    1. 捕获执行器错误

    捕获执行器中的代码，如果执行器中有代码错误，那么 Promise 的状态要变为失败

    1. // MyPromise.js
    2.  
    3. constructor(executor){
    4.   // ==== 新增 ====
    5.   // executor 是一个执行器，进入会立即执行
    6.   // 并传入resolve和reject方法
    7.   try {
    8.     executor(this.resolve, this.reject)
    9.   } catch (error) {
    10.     // 如果有错误，就直接执行 reject
    11.     this.reject(error)
    12.   }
    13. }
    14.

    验证一下：

    1. // test.js
    2.  
    3. const MyPromise = require( ./MyPromise )
    4. const promise = new MyPromise((resolve, reject) => {
    5.     // resolve( success )
    6.     throw new Error( 执行器错误 )
    7. })
    8.  
    9. promise.then(value => {
    10.   console.log(1)
    11.   console.log( resolve , value)
    12. }, reason => {
    13.   console.log(2)
    14.   console.log(reason.message)
    15. })
    16.

    执行结果 ????

    1. 2
    2. 执行器错误
    3.

    OK，通过 ????

    2. then 执行的时错误捕获
    1. // MyPromise.js
    2.  
    3. then(onFulfilled, onRejected) {
    4.   // 为了链式调用这里直接创建一个 MyPromise，并在后面 return 出去
    5.   const promise2 = new MyPromise((resolve, reject) => {
    6.     // 判断状态
    7.     if (this.status === FULFILLED) {
    8.       // 创建一个微任务等待 promise2 完成初始化
    9.       queueMicrotask(() => {
    10.         // ==== 新增 ====
    11.         try {
    12.           // 获取成功回调函数的执行结果
    13.           const x = onFulfilled(this.value);
    14.           // 传入 resolvePromise 集中处理
    15.           resolvePromise(promise2, x, resolve, reject);
    16.         } catch (error) {
    17.           reject(error)
    18.         }  
    19.       })  
    20.     } else if (this.status === REJECTED) {
    21.       // 调用失败回调，并且把原因返回
    22.       onRejected(this.reason);
    23.     } else if (this.status === PENDING) {
    24.       // 等待
    25.       // 因为不知道后面状态的变化情况，所以将成功回调和失败回调存储起来
    26.       // 等到执行成功失败函数的时候再传递
    27.       this.onFulfilledCallbacks.push(onFulfilled);
    28.       this.onRejectedCallbacks.push(onRejected);
    29.     }
    30.   }) 
    31.   
    32.   return promise2;
    33. }
    34.

    验证一下：

    1. // test.js
    2.  
    3. const MyPromise = require( ./MyPromise )
    4. const promise = new MyPromise((resolve, reject) => {
    5.     resolve( success )
    6.     // throw new Error( 执行器错误 )
    7.  })
    8.  
    9. // 第一个then方法中的错误要在第二个then方法中捕获到
    10. promise.then(value => {
    11.   console.log(1)
    12.   console.log( resolve , value)
    13.   throw new Error( then error )
    14. }, reason => {
    15.   console.log(2)
    16.   console.log(reason.message)
    17. }).then(value => {
    18.   console.log(3)
    19.   console.log(value);
    20. }, reason => {
    21.   console.log(4)
    22.   console.log(reason.message)
    23. })
    24.

    执行结果 ????

    1. 1
    2. resolve success
    3. 4
    4. then error
    5.

    这里成功打印了1中抛出的错误 then error

    七、参考 fulfilled 状态下的处理方式，对 rejected 和 pending 状态进行改造

    改造内容包括：

    1. 增加异步状态下的链式调用

    2. 增加回调函数执行结果的判断

    3. 增加识别 Promise 是否返回自己

    4. 增加错误捕获

    1. // MyPromise.js
    2.  
    3. then(onFulfilled, onRejected) {
    4.   // 为了链式调用这里直接创建一个 MyPromise，并在后面 return 出去
    5.   const promise2 = new MyPromise((resolve, reject) => {
    6.     // 判断状态
    7.     if (this.status === FULFILLED) {
    8.       // 创建一个微任务等待 promise2 完成初始化
    9.       queueMicrotask(() => {
    10.         try {
    11.           // 获取成功回调函数的执行结果
    12.           const x = onFulfilled(this.value);
    13.           // 传入 resolvePromise 集中处理
    14.           resolvePromise(promise2, x, resolve, reject);
    15.         } catch (error) {
    16.           reject(error)
    17.         } 
    18.       })  
    19.     } else if (this.status === REJECTED) { 
    20.       // ==== 新增 ====
    21.       // 创建一个微任务等待 promise2 完成初始化
    22.       queueMicrotask(() => {
    23.         try {
    24.           // 调用失败回调，并且把原因返回
    25.           const x = onRejected(this.reason);
    26.           // 传入 resolvePromise 集中处理
    27.           resolvePromise(promise2, x, resolve, reject);
    28.         } catch (error) {
    29.           reject(error)
    30.         } 
    31.       }) 
    32.     } else if (this.status === PENDING) {
    33.       // 等待
    34.       // 因为不知道后面状态的变化情况，所以将成功回调和失败回调存储起来
    35.       // 等到执行成功失败函数的时候再传递
    36.       this.onFulfilledCallbacks.push(() => {
    37.         // ==== 新增 ====
    38.         queueMicrotask(() => {
    39.           try {
    40.             // 获取成功回调函数的执行结果
    41.             const x = onFulfilled(this.value);
    42.             // 传入 resolvePromise 集中处理
    43.             resolvePromise(promise2, x, resolve, reject);
    44.           } catch (error) {
    45.             reject(error)
    46.           } 
    47.         }) 
    48.       });
    49.       this.onRejectedCallbacks.push(() => {
    50.         // ==== 新增 ====
    51.         queueMicrotask(() => {
    52.           try {
    53.             // 调用失败回调，并且把原因返回
    54.             const x = onRejected(this.reason);
    55.             // 传入 resolvePromise 集中处理
    56.             resolvePromise(promise2, x, resolve, reject);
    57.           } catch (error) {
    58.             reject(error)
    59.           } 
    60.         }) 
    61.       });
    62.     }
    63.   }) 
    64.   
    65.   return promise2;
    66. }
    67.

    八、then 中的参数变为可选

    上面我们处理 then 方法的时候都是默认传入 onFulfilled、onRejected 两个回调函数，但是实际上原生 Promise 是可以选择参数的单传或者不传，都不会影响执行。

    例如下面这种 ????

    1. // test.js
    2.  
    3. const promise = new Promise((resolve, reject) => {
    4.   resolve(100)
    5. })
    6.  
    7. promise
    8.   .then()
    9.   .then()
    10.   .then()
    11.   .then(value => console.log(value))
    12.  
    13. // 输出 100
    14.

    所以我们需要对 then 方法做一点小小的调整

    1. // MyPromise.js
    2.  
    3. then(onFulfilled, onRejected) {
    4.   // 如果不传，就使用默认函数
    5.   onFulfilled = typeof onFulfilled ===  function  ? onFulfilled : value => value;
    6.   onRejected = typeof onRejected ===  function  ? onRejected : reason => {throw reason};
    7.  
    8.   // 为了链式调用这里直接创建一个 MyPromise，并在后面 return 出去
    9.   const promise2 = new MyPromise((resolve, reject) => {
    10.   ......
    11. }
    12.  
    13.

    改造完自然是需要验证一下的

    先看情况一：resolve 之后

    1. // test.js
    2.  
    3. const MyPromise = require( ./MyPromise )
    4. const promise = new MyPromise((resolve, reject) => {
    5.   resolve( succ )
    6. })
    7.  
    8. promise.then().then().then(value => console.log(value))
    9.  
    10. // 打印 succ
    11.

    先看情况一：reject 之后

    1. // test.js
    2.  
    3. const MyPromise = require( ./MyPromise )
    4. const promise = new MyPromise((resolve, reject) => {
    5.   reject( err )
    6. })
    7.  
    8. promise.then().then().then(value => console.log(value), reason => console.log(reason))
    9.  
    10. // 打印 err
    11.

    写到这里，麻雀版的 Promise 基本完成了，鼓掌 ????????????

    九、实现 resolve 与 reject 的静态调用

    就像开头挂的那道面试题使用 return Promise.resolve 来返回一个 Promise 对象，我们用现在的手写代码尝试一下

    1. const MyPromise = require( ./MyPromise )
    2.  
    3. MyPromise.resolve().then(() => {
    4.     console.log(0);
    5.     return MyPromise.resolve(4);
    6. }).then((res) => {
    7.     console.log(res)
    8. })
    9.

    结果它报错了 ????

    1. MyPromise.resolve().then(() => {
    2.           ^
    3.  
    4. TypeError: MyPromise.resolve is not a function
    5.

    除了 Promise.resolve 还有 Promise.reject 的用法，我们都要去支持，接下来我们来实现一下

    1. // MyPromise.js
    2.  
    3. MyPromise {
    4.   ......
    5.   // resolve 静态方法
    6.   static resolve (parameter) {
    7.     // 如果传入 MyPromise 就直接返回
    8.     if (parameter instanceof MyPromise) {
    9.       return parameter;
    10.     }
    11.  
    12.     // 转成常规方式
    13.     return new MyPromise(resolve =>  {
    14.       resolve(parameter);
    15.     });
    16.   }
    17.  
    18.   // reject 静态方法
    19.   static reject (reason) {
    20.     return new MyPromise((resolve, reject) => {
    21.       reject(reason);
    22.     });
    23.   }
    24. }
    25.

    这样我们再测试上面的 ???? 就不会有问题啦

    执行结果 ????

    1. 0
    2. 4
    3.

    到这里手写工作就基本完成了，前面主要为了方便理解，所以有一些冗余代码，我规整一下

    1. // MyPromise.js
    2.  
    3. // 先定义三个常量表示状态
    4. const PENDING =  pending ;
    5. const FULFILLED =  fulfilled ;
    6. const REJECTED =  rejected ;
    7.  
    8. // 新建 MyPromise 类
    9. class MyPromise {
    10.   constructor(executor){
    11.     // executor 是一个执行器，进入会立即执行
    12.     // 并传入resolve和reject方法
    13.     try {
    14.       executor(this.resolve, this.reject)
    15.     } catch (error) {
    16.       this.reject(error)
    17.     }
    18.   }
    19.  
    20.   // 储存状态的变量，初始值是 pending
    21.   status = PENDING;
    22.   // 成功之后的值
    23.   value = null;
    24.   // 失败之后的原因
    25.   reason = null;
    26.  
    27.   // 存储成功回调函数
    28.   onFulfilledCallbacks = [];
    29.   // 存储失败回调函数
    30.   onRejectedCallbacks = [];
    31.  
    32.   // 更改成功后的状态
    33.   resolve = (value) => {
    34.     // 只有状态是等待，才执行状态修改
    35.     if (this.status === PENDING) {
    36.       // 状态修改为成功
    37.       this.status = FULFILLED;
    38.       // 保存成功之后的值
    39.       this.value = value;
    40.       // resolve里面将所有成功的回调拿出来执行
    41.       while (this.onFulfilledCallbacks.length) {
    42.         // Array.shift() 取出数组第一个元素，然后（）调用，shift不是纯函数，取出后，数组将失去该元素，直到数组为空
    43.         this.onFulfilledCallbacks.shift()(value)
    44.       }
    45.     }
    46.   }
    47.  
    48.   // 更改失败后的状态
    49.   reject = (reason) => {
    50.     // 只有状态是等待，才执行状态修改
    51.     if (this.status === PENDING) {
    52.       // 状态成功为失败
    53.       this.status = REJECTED;
    54.       // 保存失败后的原因
    55.       this.reason = reason;
    56.       // resolve里面将所有失败的回调拿出来执行
    57.       while (this.onRejectedCallbacks.length) {
    58.         this.onRejectedCallbacks.shift()(reason)
    59.       }
    60.     }
    61.   }
    62.  
    63.   then(onFulfilled, onRejected) {
    64.     const realOnFulfilled = typeof onFulfilled ===  function  ? onFulfilled : value => value;
    65.     const realOnRejected = typeof onRejected ===  function  ? onRejected : reason => {throw reason};
    66.  
    67.     // 为了链式调用这里直接创建一个 MyPromise，并在后面 return 出去
    68.     const promise2 = new MyPromise((resolve, reject) => {
    69.       const fulfilledMicrotask = () =>  {
    70.         // 创建一个微任务等待 promise2 完成初始化
    71.         queueMicrotask(() => {
    72.           try {
    73.             // 获取成功回调函数的执行结果
    74.             const x = realOnFulfilled(this.value);
    75.             // 传入 resolvePromise 集中处理
    76.             resolvePromise(promise2, x, resolve, reject);
    77.           } catch (error) {
    78.             reject(error)
    79.           } 
    80.         })  
    81.       }
    82.  
    83.       const rejectedMicrotask = () => { 
    84.         // 创建一个微任务等待 promise2 完成初始化
    85.         queueMicrotask(() => {
    86.           try {
    87.             // 调用失败回调，并且把原因返回
    88.             const x = realOnRejected(this.reason);
    89.             // 传入 resolvePromise 集中处理
    90.             resolvePromise(promise2, x, resolve, reject);
    91.           } catch (error) {
    92.             reject(error)
    93.           } 
    94.         }) 
    95.       }
    96.       // 判断状态
    97.       if (this.status === FULFILLED) {
    98.         fulfilledMicrotask() 
    99.       } else if (this.status === REJECTED) { 
    100.         rejectedMicrotask()
    101.       } else if (this.status === PENDING) {
    102.         // 等待
    103.         // 因为不知道后面状态的变化情况，所以将成功回调和失败回调存储起来
    104.         // 等到执行成功失败函数的时候再传递
    105.         this.onFulfilledCallbacks.push(fulfilledMicrotask);
    106.         this.onRejectedCallbacks.push(rejectedMicrotask);
    107.       }
    108.     }) 
    109.     
    110.     return promise2;
    111.   }
    112.  
    113.   // resolve 静态方法
    114.   static resolve (parameter) {
    115.     // 如果传入 MyPromise 就直接返回
    116.     if (parameter instanceof MyPromise) {
    117.       return parameter;
    118.     }
    119.  
    120.     // 转成常规方式
    121.     return new MyPromise(resolve =>  {
    122.       resolve(parameter);
    123.     });
    124.   }
    125.  
    126.   // reject 静态方法
    127.   static reject (reason) {
    128.     return new MyPromise((resolve, reject) => {
    129.       reject(reason);
    130.     });
    131.   }
    132. }
    133.  
    134. function resolvePromise(promise2, x, resolve, reject) {
    135.   // 如果相等了，说明return的是自己，抛出类型错误并返回
    136.   if (promise2 === x) {
    137.     return reject(new TypeError( Chaining cycle detected for promise #<Promise> ))
    138.   }
    139.   // 判断x是不是 MyPromise 实例对象
    140.   if(x instanceof MyPromise) {
    141.     // 执行 x，调用 then 方法，目的是将其状态变为 fulfilled 或者 rejected
    142.     // x.then(value => resolve(value), reason => reject(reason))
    143.     // 简化之后
    144.     x.then(resolve, reject)
    145.   } else{
    146.     // 普通值
    147.     resolve(x)
    148.   }
    149. }
    150.  
    151. module.exports = MyPromise;
    152.

    到这一步手写部分基本大功告成 ????????????

    Promise A+ 测试

    上面介绍了 Promise A+ 规范，当然我们手写的版本也得符合了这个规范才有资格叫 Promise， 不然就只能是伪 Promise 了。

    上文讲到了 promises-aplus-tests，现在我们正式开箱使用

    1. 安装一下
    1. npm install promises-aplus-tests -D
    2.
    2. 手写代码中加入 deferred
    1. // MyPromise.js
    2.  
    3. MyPromise {
    4.   ......
    5. }
    6.  
    7. MyPromise.deferred = function () {
    8.   var result = {};
    9.   result.promise = new MyPromise(function (resolve, reject) {
    10.     result.resolve = resolve;
    11.     result.reject = reject;
    12.   });
    13.  
    14.   return result;
    15. }
    16. module.exports = MyPromise;
    17.
    3. 配置启动命令
    1. {
    2.   "name": "promise",
    3.   "version": "1.0.0",
    4.   "description": "my promise",
    5.   "main": "MyPromise.js",
    6.   "scripts": {
    7.     "test": "promises-aplus-tests MyPromise"
    8.   },
    9.   "author": "ITEM",
    10.   "license": "ISC",
    11.   "devDependencies": {
    12.     "promises-aplus-tests": "^2.1.2"
    13.   }
    14. }
    15.  
    16.

    开启测试

    1. npm run test
    2.

    迫不及待了吧 ???? 看看我们的结果如何，走起 ????‍????

    fail.gif

    虽然功能上没啥问题，但是测试却失败了 ????

    针对提示信息，我翻看了一下 Promise A+ 规范，发现我们应该是在 2.3.x 上出现了问题，这里规范使用了不同的方式进行了 then 的返回值判断。

    image.png

    自红线向下的细节，我们都没有处理，这里要求判断 x 是否为 object 或者 function，满足则接着判断 x.then 是否存在，这里可以理解为判断 x 是否为 promise，这里都功能实际与我们手写版本中 x instanceof MyPromise 功能相似。

    我们还是按照规范改造一下 resolvePromise 方法吧

    1. // MyPromise.js
    2.  
    3. function resolvePromise(promise, x, resolve, reject) {
    4.   // 如果相等了，说明return的是自己，抛出类型错误并返回
    5.   if (promise === x) {
    6.     return reject(new TypeError( The promise and the return value are the same ));
    7.   }
    8.  
    9.   if (typeof x ===  object  || typeof x ===  function ) {
    10.     // x 为 null 直接返回，走后面的逻辑会报错
    11.     if (x === null) {
    12.       return resolve(x);
    13.     }
    14.  
    15.     let then;
    16.     try {
    17.       // 把 x.then 赋值给 then 
    18.       then = x.then;
    19.     } catch (error) {
    20.       // 如果取 x.then 的值时抛出错误 error ，则以 error 为据因拒绝 promise
    21.       return reject(error);
    22.     }
    23.  
    24.     // 如果 then 是函数
    25.     if (typeof then ===  function ) {
    26.       let called = false;
    27.       try {
    28.         then.call(
    29.           x, // this 指向 x
    30.           // 如果 resolvePromise 以值 y 为参数被调用，则运行 [[Resolve]](promise, y)
    31.           y => {
    32.             // 如果 resolvePromise 和 rejectPromise 均被调用，
    33.             // 或者被同一参数调用了多次，则优先采用首次调用并忽略剩下的调用
    34.             // 实现这条需要前面加一个变量 called
    35.             if (called) return;
    36.             called = true;
    37.             resolvePromise(promise, y, resolve, reject);
    38.           },
    39.           // 如果 rejectPromise 以据因 r 为参数被调用，则以据因 r 拒绝 promise
    40.           r => {
    41.             if (called) return;
    42.             called = true;
    43.             reject(r);
    44.           });
    45.       } catch (error) {
    46.         // 如果调用 then 方法抛出了异常 error：
    47.         // 如果 resolvePromise 或 rejectPromise 已经被调用，直接返回
    48.         if (called) return;
    49.  
    50.         // 否则以 error 为据因拒绝 promise
    51.         reject(error);
    52.       }
    53.     } else {
    54.       // 如果 then 不是函数，以 x 为参数执行 promise
    55.       resolve(x);
    56.     }
    57.   } else {
    58.     // 如果 x 不为对象或者函数，以 x 为参数执行 promise
    59.     resolve(x);
    60.   }
    61. }
    62.

    改造后启动测试

    success.gif

    完美通过 ????????????

    最终时刻，如何解释那道面试题的执行结果

    先用我们自己的 Promise 运行一下那道面试题 ????

    1. // test.js
    2.  
    3. const MyPromise = require( ./MyPromise.js )
    4.  
    5. MyPromise.resolve().then(() => {
    6.   console.log(0);
    7.   return MyPromise.resolve(4);
    8. }).then((res) => {
    9.   console.log(res)
    10. })
    11.  
    12. MyPromise.resolve().then(() => {
    13.   console.log(1);
    14. }).then(() => {
    15.   console.log(2);
    16. }).then(() => {
    17.   console.log(3);
    18. }).then(() => {
    19.   console.log(5);
    20. }).then(() =>{
    21.   console.log(6);
    22. })
    23.

    执行结果：0、1、2、4、3、5、6 ????

    这里我们手写版本的 4 并没有和 原生 Promise 一样在 3 后面，而是在 2 后面

    其实从我们的手写代码上看，在判断 then 内部函数执行结果，也就是在这里 ????

    1. // MyPromise.js
    2.  
    3. // 获取成功回调函数的执行结果
    4. const x = realOnFulfilled(this.value);
    5. // 传入 resolvePromise 集中处理
    6. resolvePromise(promise2, x, resolve, reject);
    7.

    面试题中 x 为 MyPromise.resolve(4) 的时候，在传入 resolvePromise 方法中会对 x 的类型进行判断时，会发现它是一个 Promise，并让其调用 then 方法完成状态转换。再看 resolvePromis 方法中这一块判断逻辑 ????

    1. if (typeof x ===  object  || typeof x ===  function ) {
    2.     // x 为 null 直接返回，走后面的逻辑会报错
    3.     if (x === null) {
    4.       return resolve(x);
    5.     }
    6.  
    7.     let then;
    8.     try {
    9.       // 把 x.then 赋值给 then 
    10.       then = x.then;
    11.     } catch (error) {
    12.       // 如果取 x.then 的值时抛出错误 error ，则以 error 为据因拒绝 promise
    13.       return reject(error);
    14.     }
    15.  
    16.     // 如果 then 是函数
    17.     if (typeof then ===  function ) {
    18.       let called = false;
    19.       try {
    20.         then.call(
    21.           x, // this 指向 x
    22.           // 如果 resolvePromise 以值 y 为参数被调用，则运行 [[Resolve]](promise, y)
    23.           y => {
    24.             // 如果 resolvePromise 和 rejectPromise 均被调用，
    25.             // 或者被同一参数调用了多次，则优先采用首次调用并忽略剩下的调用
    26.             // 实现这条需要前面加一个变量 called
    27.             if (called) return;
    28.             called = true;
    29.             resolvePromise(promise, y, resolve, reject);
    30.           },
    31.           // 如果 rejectPromise 以据因 r 为参数被调用，则以据因 r 拒绝 promise
    32.           r => {
    33.             if (called) return;
    34.             called = true;
    35.             reject(r);
    36.           });
    37.       } 
    38.       ......   
    39.

    那么问题来了

    • 为什么我们 Promise A+ 测试全部通过的手写代码，执行结果却与原生 Promise 不同？

    • 在我们手写代码使用创建一次微任务的方式，会带来什么问题吗？

    ES6 中的 Promise 虽然是遵循 Promise A+ 规范实现的，但实际上也 Promise A+ 上做了一些功能扩展，例如：Promise.all、Promise.race 等，所以即使都符合 Promise A+ ，执行结果也是可能存在差异的。我们这里更需要思考的是第二个问题，不这么做会带来什么问题，也就是加一次微任务的必要性。

    我尝试过很多例子，都没有找到相关例证，我们手写实现的 Promise 都很好的完成工作，拿到了结果。我不得不去翻看更多的相关文章，我发现有些人会为了让执行结果与原生相同，强行去再多加一次微任务，这种做法是很牵强的。

    毕竟实现 Promise 的目的是为了解决异步编程的问题，能够拿到正确的结果才是最重要的，强行为了符合面试题的输出顺序去多加一次微任务，只能让手写代码变的更加复杂，不好理解。

    在 stackoverflow 上，有一个类似的问题 What is the difference between returned Promise? 回答中有一个信息就是

    It only required the execution context stack contains only platform code. 也就相当于等待 execution context stack 清空。

    这个在掘金中的一篇文章 我以为我很懂Promise，直到我开始实现Promise/A+规范 也有一段关于这道面试题的讨论

    return Promise.resolve(4)，JS引擎会安排一个job（job是 ECMA 中的概念，等同于微任务的概念)，其回调目的是让其状态变为fulfilled。

    实际上我们已经在 static resolve 创建了一个新的 MyPromsie，并调用其 then 方法，创建了一个微任务。

    所以，就目前的信息来说，两次微任务依旧不能证明其必要性，目前的 Promise 日常操作，一次微任务都是可以满足。

    大家对于这个道面试题有什么想法或者意见，赶紧在留言区告诉我吧，一起探讨一下到底是必然还是巧合????

    长文整理不易，记得 点赞 ???? 支持一下哦 ????

    关于本文

    作者：ITEM

    https://juejin.cn/post/6945319439772434469

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/876539
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号