• 手写 Promise

    最近重温了一下 Q/Promise[1] 的设计讲解，结合自己的理解和一些小优化，决定也来写一篇手写 Promise 的文章。本文的内容适合对 Promise 的使用有一定了解的童鞋，因为过程中不会过多解释 Promise 的基础操作。我们从一个基础版本开始，渐进式地完成这个 Promise，在过程中分享我的理解和观点。内容可能有点长，废话不多说，我们开始吧。

    基础版本

    我们先以观察者模式作为基石来搭建一个基础版本，实现的功能如下：

    1. 构造函数接受一个函数 exector 作为参数，该函数的第一个参数是 resolve，作用是把 Promise 对象的状态变为“成功”。

    2. 原型方法 then 是用来注册一个当状态变为成功的回调函数，当回调触发时，参数是 resolve 时的决议值。

    1. function Promise(exector) {
    2.   this.pending = [];
    3.   this.value = undefined;
    4.  
    5.   const resolve = value => {
    6.     if (this.pending) {
    7.       this.value = value;
    8.       for (const onFulfilled of this.pending) {
    9.         // 通知观察者。
    10.         onFulfilled(this.value);
    11.       }
    12.       this.pending = undefined;
    13.     }
    14.   };
    15.  
    16.   exector(resolve);
    17. }
    18.  
    19. Promise.prototype.then = function (onFulfilled) {
    20.   if (this.pending) {
    21.     // 还没决议，先注册观察者。
    22.     this.pending.push(onFulfilled);
    23.   } else {
    24.     // 已决议，直接通知。
    25.     onFulfilled(this.value);
    26.   }
    27. };
    28.  
    29. // 测试一下。
    30. const p = new Promise(resolve => {
    31.   setTimeout(() => resolve(666), 100);
    32. })
    33.  
    34. p.then(res => console.log('res: %s', res));
    35.  
    36. // 输出：
    37. // res: 666

    代码很简单，应该不用过多解释，上面的完整代码在这里：p0.js[2]。

    这个基础版本有个明显的问题：then  不能进行链式调用，接着就来优化一下。

    then 链式调用

    then 的链式调用会返回一个新的 Promise，并且 then 中回调的返回值会使这个新的 Promise 决议为“成功”状态。

    1. Promise.prototype.then = function (onFulfilled) {
    2.   // “当前”Promise，对于返回的新 Promise 而言，也是“前一个”Promise。
    3.   const prev = this;
    4.  
    5.   const promise = new Promise(resolve => {
    6.     // 包装 onFulfilled，使其可以“传播”决议；
    7.     // “前一个” Promise 决议后，决议返回的这个新 Promise。
    8.     const onSpreadFulfilled = function (value) {
    9.       resolve(onFulfilled(value));
    10.     };
    11.  
    12.     if (prev.pending) {
    13.       prev.pending.push(onSpreadFulfilled);
    14.     } else {
    15.       onSpreadFulfilled(prev.value);
    16.     }
    17.   });
    18.  
    19.   return promise;
    20. };
    21.  
    22. // 测试一下。
    23. const p = new Promise(resolve => {
    24.   setTimeout(() => resolve(666), 100);
    25. });
    26.  
    27. p.then(res => {
    28.   console.log('res1: %s', res);
    29.   return res + 1;
    30. ).then(res => {
    31.   console.log('res2: %s', res);
    32. );
    33.   
    34. // 输出：
    35. // res1: 666
    36. // res2: 667

    实现链式调用的关键是如何决议返回的新 Promise？这里我对变量做了一些有含义的命名，方便理解：

    1. prev 是调用 then 时“当前”的 Promise，对于返回的新 Promise 而言，可以看做是“前一个”Promise。

    2. 包装 onFulfilled——执行完当前注册的 onFulfilled 后，用其返回值来决议返回的那个新的 Promise。这是个关键步骤，为体现传播的动作，将其命名为 onSpreadFulfilled。

    3. 将 onSpreadFulfilled 作为成功的回调注册到 prev 上。

    上面的完整代码在这里：p1.js[3]。

    现在又有个新问题，如果 resolve 的 value 是个 Promise，或者 onfulfilled 函数返回的结果是个 Promise，那么链式传播的决议值不应该是这个 Promise 本身，而是这个 Promise 的决议值才对，也就是要支持 Promise 的状态传递。

    状态传递

    在实现状态传递之前，我们先来康康如何确定一个值是不是 Promise。我们可以用原型继承来判断：

    return value instanceof Promise;

    这样的缺点是兼容性较差，你无法强制使用者的运行环境上下文中只会用一种 Promise 的库，或者在不同的运行上下文中传递 Promise 实例。所以这里我们使用 鸭子类型[4] 来判断 Promise，重点关注对象的行为，将 Promise 看作是一个 thenable 对象。

    1. function isPromise(value) {
    2.   // 如果这个对象上可以调用 then 方法，就认为它是一个“Promise”了。
    3.   return value && typeof value.then === 'function';
    4. }

    接下来就来实现状态传递了，实现的思路就是基于鸭子类型和“通知转移”。我们先定义一个函数：

    1. function wrapToThenable(value) {
    2.   if (isPromise(value)) {
    3.     return value;
    4.   } else {
    5.     return {
    6.       then: function (onFulfilled) {
    7.         return wrapToThenable(onFulfilled(value));
    8.       }
    9.     };
    10.   }
    11. }

    顾名思义，这个函数的作用是用来把一个值包装为 thenable 对象：如果 value 是 Promise 则直接返回；如果不是就包装并返回一个有 then 方法的对象，也就是 thenable 对象。这个 thenable 对象的作用是啥呢？接着看这里：

    1. function Promise(exector) {
    2.   this.pending = [];
    3.   this.value = undefined;
    4.  
    5.   const resolve = value => {
    6.     if (this.pending) {
    7.       // 包装为 thenable。
    8.       this.value = wrapToThenable(value);
    9.       for (const onFulfilled of this.pending) {
    10.         // 通知时改为调用 thenable 上的 then。
    11.         this.value.then(onFulfilled);
    12.       }
    13.       this.pending = undefined;
    14.     }
    15.   };
    16.  
    17.   exector(resolve);
    18. }

    resolve 决议时，根据 value 的类型不同，有两种处理情况：

    1. 如果 value 是普通值，经过 wrapToThenable 会包装为 thenable 对象，通知时调用 then 方法相当于直接调用 onFulfilled。

    2. 如果 value 是 Promise，则把 onFulfilled 注册到 value 上；等到 value 决议时，就会调用 onFulfilled。还记得链式调用时的 onSpreadFulfilled 吗？这里就是“通知转移”了，把通知下一个 Promise 的责任转移到了 value 身上。

    当然 then 也要做一点修改：

    1. Promise.prototype.then = function (onFulfilled) {
    2.   const prev = this;
    3.  
    4.   const promise = new Promise(resolve => {
    5.     const onSpreadFulfilled = function (value) {
    6.       resolve(onFulfilled(value));
    7.     };
    8.  
    9.     if (prev.pending) {
    10.       prev.pending.push(onSpreadFulfilled);
    11.     } else {
    12.       // 这里也要改为调用 then。
    13.       prev.value.then(onSpreadFulfilled);
    14.     }
    15.   });
    16.  
    17.   return promise;
    18. };
    19.  
    20. // 测试一下。
    21. const p = new Promise(resolve => {
    22.   setTimeout(() => resolve(666), 100);
    23. });
    24.  
    25. p.then(res => {
    26.   console.log('res1: %s', res);
    27.   return new Promise(resolve => {
    28.     setTimeout(() => resolve(777), 100);
    29.   });
    30. }).then(res => {
    31.   console.log('res2: %s', res);
    32. });
    33.  
    34. // 输出：
    35. // res1: 666
    36. // res2: 777

    这里来总结一下状态传递的设计思路。包装为 thenable 对象非常关键，作用是保持了与 Promise 一致的行为，也就是接口一致。这样在 resolve 时我们不用特定去判断这个值是不是 Promise，而可以用统一的处理方式来通知观察者；并且也顺便完成了“通知转移”，如果 value 还没有决议，则 then 会注册为回调，如果已决议则 then 会立即执行。

    上面的完整代码在这里：p2.js[5]。接下来，我们来完善一下 reject。

    失败状态

    当 Promise 决议失败时，then 方法里面将只执行第二个参数 onRejected 对应的回调。首先我们需要另一个包装函数：

    1. function wrapToRejected(value) {
    2.   return {
    3.     then: function (_, onRejected) {
    4.       return wrapToThenable(onRejected(value));
    5.     }
    6.   };
    7. }

    这个函数的作用是一旦发生 reject(value) 时，我们把 value 变为另一种 thenable 对象，这个对象在执行 then 时只会调用 onRejected。

    然后改变一下构造函数：

    1. function Promise(exector) {
    2.   // pending 变为一个二维数组，里面存放的元素是 [onFulfilled, onRejected]。
    3.   this.pending = [];
    4.   this.value = undefined;
    5.  
    6.   const resolve = value => {
    7.     if (this.pending) {
    8.       this.value = wrapToThenable(value);
    9.       for (const handlers of this.pending) {
    10.         this.value.then.apply(this.value, handlers);
    11.       }
    12.       this.pending = undefined;
    13.     }
    14.   };
    15.  
    16.   const reject = value => {
    17.     resolve(wrapToRejected(value));
    18.   };
    19.  
    20.   exector(resolve, reject);
    21. }

    现在有一个比较大的变化：this.pending 变为了二维数组。这样 this.value.then.apply 在执行时会有三种情况：

    1. this.value 是成功决议转换来的 thenable 对象，还记得 wrapToThenable 吗？then 被执行时只会调用 onFulfilled。

    2. this.value 是失败决议转换来的 thenable 对象，then 被执行时只会调用 onRejected。

    3. this.value 是一个 Promise，决议会转移到这个 Promise 上。

    同样 then 方法也要做一些修改：

    1. Promise.prototype.then = function (onFulfilled, onRejected) {
    2.   const prev = this;
    3.   
    4.   // 注意这里给了 onFulfilled、onRejected 默认值。
    5.   onFulfilled =
    6.     onFulfilled ||
    7.     function (value) {
    8.       return value;
    9.     };
    10.   onRejected =
    11.     onRejected ||
    12.     function (value) {
    13.       return wrapToRejected(value);
    14.     };
    15.  
    16.   const promise = new Promise(resolve => {
    17.     const onSpreadFulfilled = function (value) {
    18.       resolve(onFulfilled(value));
    19.     };
    20.     const onSpreadRejected = function (value) {
    21.       resolve(onRejected(value));
    22.     };
    23.  
    24.     if (prev.pending) {
    25.       prev.pending.push([onSpreadFulfilled, onSpreadRejected]);
    26.     } else {
    27.       prev.value.then(onSpreadFulfilled, onSpreadRejected);
    28.     }
    29.   });
    30.  
    31.   return promise;
    32. };
    33.  
    34. // 测试一下。
    35. const p = new Promise((resolve, reject) => {
    36.   setTimeout(() => reject(666), 100);
    37. });
    38.  
    39. p.then(undefined, err => {
    40.   console.log('err1: %s', err);
    41.   return 1;
    42. }).then(res => {
    43.   console.log('res1: %s', res);
    44. });
    45.  
    46. // 输出：
    47. // err1: 666
    48. // res1: 1

    我们要特别注意一下增加了 onFulfilled、onRejected 的默认值。在实际使用 then 时，可能只会专注处理成功或者失败的回调，但是我们又需要另外一种状态要继续传播下去。这里可能有点不好理解，可以代入数据模拟一下。上面的完整代码在这里：p3.js[6]。

    又到了思考总结时间，thenable 这个接口是关键所在。通过两个包装对象，分别处理成功和失败的状态，在通知观察者时可以保持统一的逻辑，这个设计是不是感觉很妙呢？

    接下来我们要处理一下调用时会产生异常的问题。

    异常处理

     

    我们先思考一下会有哪些地方会产生异常？第一个是构造函数里面 exector 执行的时候：

    1. function Promise(exector) {
    2.   this.pending = [];
    3.   this.value = undefined;
    4.  
    5.   const resolve = value => {
    6.     // ...
    7.   };
    8.  
    9.   const reject = value => {
    10.     resolve(wrapToRejected(value));
    11.   };
    12.  
    13.   try {
    14.     exector(resolve, reject);
    15.   } catch (e) {
    16.     // 如果有异常产生，状态变为“失败”。
    17.     reject(e);
    18.   }
    19. }

    然后是onFulfilled 和 onRejected 执行的时候。当在以上两个方法里产生异常时，状态要变为失败，并且需要把异常传播下去。then 的改动如下：

    1. Promise.prototype.then = function (onFulfilled, onRejected) {
    2.   // ...
    3.   // 产生异常的时候包装一下。
    4.   const errHandler = returnWhenError(err => wrapToRejected(err));
    5.   onFulfilled = errHandler(onFulfilled);
    6.   onRejected = errHandler(onRejected);
    7.  
    8.   const promise = new Promise(resolve => {
    9.     const onSpreadFulfilled = function (value) {
    10.       resolve(onFulfilled(value));
    11.     };
    12.     const onSpreadRejected = function (value) {
    13.       resolve(onRejected(value));
    14.     };
    15.  
    16.     if (prev.pending) {
    17.       prev.pending.push([onSpreadFulfilled, onSpreadRejected]);
    18.     } else {
    19.       prev.value.then(onSpreadFulfilled, onSpreadRejected);
    20.     }
    21.   });
    22.  
    23.   return promise;
    24. };
    25.  
    26. // 封装为一个可重用的高阶函数。
    27. // 如果 fun 执行失败了，则返回 onError 的结果。
    28. function returnWhenError(onError) {
    29.   return fun =>
    30.     (...args) => {
    31.       let result;
    32.  
    33.       try {
    34.         result = fun(...args);
    35.       } catch (e) {
    36.         result = onError(e);
    37.       }
    38.  
    39.       return result;
    40.     };
    41. }

    然后我们可以加入 catch 方法：

    1. Promise.prototype.catch = function (onRejected) {
    2.   // 在 then 中忽略掉“成功”状态的回调。
    3.   return Promise.prototype.then.call(this, undefined, onRejected);
    4. };
    5.  
    6. // 测试一下。
    7. const p = new Promise(resolve => {
    8.   setTimeout(() => resolve(666), 100);
    9. });
    10.  
    11. p.then(res => {
    12.   console.log('res1: %s', res);
    13.   throw new Error('test error1');
    14. }).then(undefined, err => {
    15.   console.log('err1: %s', err.message);
    16.   throw new Error('test error2');
    17. }).catch(err => {
    18.   console.log('err2: %s', err.message);
    19. });
    20.  
    21. // 输出：
    22. // res1: 666
    23. // err1: test error1
    24. // err2: test error2

    上面的完整代码在这里：p4.js[7]。

    到了这里，基本上 Promise 的基本功能就差不多完成了。不过还有一些不太完善的地方，我们来继续做一些优化。

    一些优化

    封装私有变量

    this.pending 和 this.value 从外部是可以读写的，不够安全和健壮。而我又还是想用构造函数和原型方法，不想用闭包来封装。我这里采用的是 WeakMap[8] 来达到目的，关键的修改如下：

    1. const refMap = new WeakMap();
    2.  
    3. // ...
    4.  
    5. function Promise(exector) {
    6.   // 用当前的实例引用作为 key，把想隐藏的数据放进一个对象里。
    7.   refMap.set(this, {
    8.     pending: [],
    9.     value: undefined
    10.   });
    11.  
    12.   const resolve = value => {
    13.     // 取出封装的数据。
    14.     const data = refMap.get(this);
    15.  
    16.     if (data.pending) {
    17.       data.value = wrapToThenable(value);
    18.       for (const handlers of data.pending) {
    19.         data.value.then.apply(data.value, handlers);
    20.       }
    21.       data.pending = undefined;
    22.     }
    23.   };
    24.  
    25.   // ...
    26. }

    同样 then 也修改一下：

    1. Promise.prototype.then = function (onFulfilled, onRejected) {
    2.   // ...
    3.  
    4.   const promise = new Promise(resolve => {
    5.     const onSpreadFulfilled = function (value) {
    6.       resolve(onFulfilled(value));
    7.     };
    8.     const onSpreadRejected = function (value) {
    9.       resolve(onRejected(value));
    10.     };
    11.     // 取出封装的数据。
    12.     const data = refMap.get(prev);
    13.  
    14.     if (data.pending) {
    15.       data.pending.push([onSpreadFulfilled, onSpreadRejected]);
    16.     } else {
    17.       data.value.then(onSpreadFulfilled, onSpreadRejected);
    18.     }
    19.   });
    20.  
    21.   return promise;
    22. };

    上面的完整代码在这里：p5.js[9]。

    当 Promise 实例被垃圾回收时，对应在 WeakMap 中的私有数据对象引用也会被消除，没有内存泄漏问题，这种方案非常适合用来封装私有变量。

    调用顺序

    目前的 Promise 在执行时有调用顺序问题，比如：

    1. const p = new Promise(resolve => resolve(1));
    2.  
    3. p.then(res => {
    4.   console.log('res1:', res);
    5.   return res + 1;
    6. }).then(res => {
    7.   console.log('res2:', res);
    8. });
    9.  
    10. p.then(res => {
    11.   console.log('res3:', res);
    12. });
    13.  
    14. console.log('Hi!');
    15.  
    16. // 目前的输出是：
    17. // res1: 1
    18. // res2: 2
    19. // res3: 1
    20. // Hi!
    21.  
    22. // 正确的输出应该是：
    23. // Hi!
    24. // res1: 1
    25. // res3: 1
    26. // res2: 2

    一个简单的做法是利用 setTimeout 来改进：

    1. function Promise(exector) {
    2.   // ...
    3.   
    4.   const resolve = value => {
    5.     const data = refMap.get(this);
    6.  
    7.     if (data.pending) {
    8.       data.value = wrapToThenable(value);
    9.       for (const handlers of data.pending) {
    10.         // 延迟执行。
    11.         enqueue(() => {
    12.           data.value.then.apply(data.value, handlers);
    13.         });
    14.       }
    15.       data.pending = undefined;
    16.     }
    17.   };
    18.   
    19.   // ...
    20. }
    21.  
    22. Promise.prototype.then = function (onFulfilled, onRejected) {
    23.   // ...
    24.  
    25.   const promise = new Promise(resolve => {
    26.     // ...
    27.  
    28.     if (data.pending) {
    29.       data.pending.push([onSpreadFulfilled, onSpreadRejected]);
    30.     } else {
    31.       // 延迟执行。
    32.       enqueue(() => {
    33.         data.value.then(onSpreadFulfilled, onSpreadRejected);
    34.       });
    35.     }
    36.   });
    37.  
    38.   return promise;
    39. };
    40.  
    41. function enqueue(callback) {
    42.   setTimeout(callback, 1);
    43. }

    enqueue 的作用是模拟按入队顺序来延迟执行函数。通过对所有 then 调用的延迟执行，可以保证按正确的注册顺序和决议顺序来执行了，上面的完整代码在这里：p6.js[10]。

    接下来呢？

    到了这里我觉得就先差不多了，毕竟此文的目的是分享和交流一种 Promise 的设计思路和心得，而不是去造一个完美的 Promise。手写一个 Promise 这个结果不应该是我们的目的，观察演进过程中的思路和方案才是我们需要吸收的东西。

  • 相关阅读:
    Executors工具类的相关方法
    linux dolphin为tags协议服务的进程意外退出,kioslave5已经意外关闭
    Ubuntu 20.04 下DeepSDF环境配置笔记
    pandas教程：Date Ranges, Frequencies, and Shifting 日期范围，频度，和位移
    私有化部署 给数据安全加把“锁”！
    Java-IO流学习
    【多线程】线程池
    sql报错：sql injection violation, syntax error
    胡说八道(24.6.11)——数电及STM32
    QMudiaPlayer（状态）
  • 原文地址：https://blog.csdn.net/why_1639946449/article/details/133050228