1. const PENDING = 'pending';
  2. const FULFILLED = 'fulfilled';
  3. const REJECTED = 'rejected';
  5. class MyPromise {
  6.     constructor (executor) {
  7.         this._status = PENDING;
  8.         this._value = undefined;
  9.         this._resolveQueue = [];
  10.         this._rejectQueue = [];
  12.         let _resolve = (val) => {
  13.             const run = () => {
  14.                 if (this._status !== PENDING) return;
  15.                 this._status = FULFILLED;
  16.                 this._value = val;
  18.                 while (this._resolveQueue.length) {
  19.                     const callback = this._resolveQueue.shift();
  21.                     callback(val);
  22.                 }
  23.             };
  25.             setTimeout(run);
  26.         };
  28.         let _reject = (val) => {
  29.             const run = () => {
  30.                 if (this._status !== PENDING) return;
  31.                 this._status = REJECTED;
  32.                 this._value = val;
  34.                 while (this._rejectQueue.length) {
  35.                     const callback = this._rejectQueue.shift();
  37.                     callback(val);
  38.                 }
  39.             };
  40.             setTimeout(run);
  41.         };
  43.         executor(_resolve, _reject);
  44.     }
  46.     then (resolveFn, rejectFn) {
  47.         typeof resolveFn !== 'function' ? resolveFn = value => value : null;
  48.         typeof rejectFn !== 'function' ? rejectFn = reason => {
  49.             throw new Error(reason instanceof Error ? reason.message : reason);
  50.         } : null;
  52.         return new MyPromise((resolve, reject) => {
  53.             let fulfilledFn = (val) => {
  54.                 try {
  55.                     let x = resolveFn(val);
  57.                     x instanceof MyPromise ? x.then(resolve, reject) : resolve(x);
  58.                 } catch (e) {
  59.                     reject(e);
  60.                 }
  61.             };
  63.             let rejectedFn = (error) => {
  64.                 try {
  65.                     let x = rejectFn(error);
  67.                     x instanceof MyPromise ? x.then(resolve, reject) : resolve(x);
  68.                 } catch (error) {
  69.                     reject(error);
  70.                 }
  71.             };
  73.             switch (this._status) {
  74.                 case FULFILLED:
  75.                     fulfilledFn(this._value);
  76.                     break;
  77.                 case REJECTED:
  78.                     rejectedFn(this._value);
  79.                     break;
  80.                 case PENDING:
  81.                     this._resolveQueue.push(fulfilledFn);
  82.                     this._rejectQueue.push(rejectedFn);
  83.                     break;
  85.             }
  86.         });
  87.     };
  89.     catch (rejectFn) {
  90.         return this.then(undefined, rejectFn);
  91.     }
  93.     finally (callback) {
  94.         return this.then(
  95.             value => MyPromise.resolve(callback()).then(() => value),
  96.             reason => MyPromise.resolve(callback()).then(() => {
  97.                 throw reason;
  98.             }));
  99.     }
  101.     static resolve (value) {
  102.         if (value instanceof MyPromise) return value;
  103.         return new MyPromise((resolve) => resolve(value))
  104.     }
  106.     static reject (reason) {
  107.         return new MyPromise((resolve, reject) => reject(reason))
  108.     }
  110.     static all (promiseArr) {
  111.         let index = 0;
  112.         let result = [];
  113.         return new MyPromise((resolve, reject) => {
  114.             promiseArr.forEach((p, i) => {
  115.                 MyPromise.resolve(p).then(
  116.                     val => {
  117.                         result[i] = val;
  118.                         index++;
  119.                         if (index === promiseArr.length) {
  120.                             resolve(result);
  121.                         }
  122.                     },
  123.                     err => {
  124.                         reject(err);
  125.                     });
  126.             });
  127.         });
  128.     }
  130.     static race (promiseArr) {
  131.         return new MyPromise((resolve, reject) => {
  132.             for (let p of promiseArr) {
  133.                 MyPromise.resolve(p).then(
  134.                     val => {
  135.                         resolve(val);
  136.                     },
  137.                     err => {
  138.                         reject(err);
  139.                     });
  140.             }
  141.         });
  142.     }
  143. }
  145. //
  146. // new MyPromise((resolve, reject) => {
  147. //     resolve('kkk')
  148. // })
  149. //     .then(result => {
  150. //         console.log(result);
  151. //         return MyPromise.reject('reject')
  152. //     })
  153. //     .catch(error => {
  154. //         console.log(error);
  155. //         return 'jjj'
  156. //     })
  157. //     .finally((res) => {
  158. //         console.log(666);
  159. //         console.log(res);
  160. //         return 'rr'
  161. //     }).then(res => {
  162. //     console.log(999);
  163. //     console.log(res);
  164. // });
  166. let sss = MyPromise.race([new MyPromise(resolve => {
  167.     setTimeout(() => {
  168.         resolve(6666)
  169.     }, 1000)
  170. }), 11, MyPromise.resolve(66), new MyPromise(resolve => {
  171.     setTimeout(() => {
  172.         resolve(999)
  173.     })
  174. })]).then(res => {
  175.     console.log(res);
  176. });

参考文档：

https://juejin.im/post/6844904096525189128 （9k字 | Promise/async/Generator实现原理解析）
https://juejin.im/post/6844903922964889608#heading-4 （手写Promise）
https://www.icode9.com/content-4-365156.html （Promise A+ 规范【中文版】）
https://juejin.cn/post/6844903607968481287#heading-0 （Promise不会？？看这里！！！史上最通俗易懂的Promise！！！）