Promise 规范有很多，如 Promise/A ， Promise/B ，Promise/D 以及 Promise/A 的 升级版 Promise/A+ 。最终 ES6 中采用了 Promise/A+ 规范。（Promise/A+规范中文翻译）

    1. const PENDING = 'pending'; // 等待态
    2. const FULFILLED = 'fulfilled'; // 执行态
    3. const REJECTED = 'rejected'; // 拒绝态
    5. class MyPromise {
    6.   constructor(fn) {
    7.     this.value = null;
    8.     this.error = null;
    9.     this.status = PENDING;
    10.     // 当promise为pending状态时，存储回调函数
    11.     // 用于实现异步串行
    12.     this.onFulfilledCallbacks = [];
    13.     this.onRejectedCallbacks = [];
    15.     const resolve = (value) => {
    16.       if (this.status === PENDING) {
    17.         this.status = FULFILLED;
    18.         this.value = value;
    19.         // callback(this.value);
    20.         this.onFulfilledCallbacks.forEach((callback) => callback(this.value));
    21.       }
    22.     };
    24.     const reject = (error) => {
    25.       if (this.status === PENDING) {
    26.         this.status = REJECTED;
    27.         this.error = error;
    28.         this.onRejectedCallbacks.forEach((callback) => callback(this.error));
    29.       }
    30.     };
    32.     try {
    33.       fn(resolve, reject);
    34.     } catch (error) {
    35.       reject(error);
    36.     }
    37.   }
    39.   // onFulfilled 当 promise 执行结束后其必须被调用，其第一个参数为 promise 的终值
    40.   // onRejected 当 promise 被拒绝执行后其必须被调用，其第一个参数为 promise 的据因
    41.   then(onFulfilled, onRejected) {
    42.     let bridgePromise;
    43.     // 默认给个函数
    44.     onFulfilled =
    45.       typeof onFulfilled === 'function' ? onFulfilled : (value) => value;
    46.     onRejected =
    47.       typeof onRejected === 'function'
    48.         ? onRejected
    49.         : (error) => {
    50.             throw error;
    51.           };
    52.     if (this.status === FULFILLED) {
    53.       bridgePromise = new MyPromise((resolve, reject) => {
    54.         // A+规范，异步执行
    55.         setTimeout(() => {
    56.           try {
    57.             const x = onFulfilled(this.value); 
    58.             resolvePromise(bridgePromise, x, resolve, reject);
    59.           } catch (e) {
    60.             reject(e);
    61.           }
    62.         });
    63.       });
    65.       return bridgePromise;
    66.     }
    68.     if (this.status === REJECTED) {
    69.       bridgePromise = new MyPromise((resolve, reject) => {
    70.         setTimeout(() => {
    71.           try {
    72.             const x = onRejected(this.error);
    73.             resolvePromise(bridgePromise, x, resolve, reject);
    74.           } catch (e) {
    75.             reject(e);
    76.           }
    77.         });
    78.       });
    80.       return bridgePromise;
    81.     }
    83.     if (this.status === PENDING) {
    84.       bridgePromise = new MyPromise((resolve, reject) => {
    85.         // 处理异步resolve
    86.         // 回调函数放入 onFulfilledCallbacks 中
    87.         // 回调函数负责执行 onFulfilled 和 更新 bridgePromise 的状态
    88.         // promise.then().then()
    89.         // 当前 promise 的 onFulfilledCallbacks 里的回调函数
    90.         // 负责执行.then里面的回调函数和更新.then返回的bridgePromise状态
    91.         this.onFulfilledCallbacks.push((value) => {
    92.           setTimeout(() => {
    93.             try {
    94.               // 执行回调
    95.               const x = onFulfilled(value);
    96.               // resolve(x)下去
    97.               resolvePromise(bridgePromise, x, resolve, reject);
    98.             } catch (e) {
    99.               reject(e);
    100.             }
    101.           });
    102.         });
    104.         this.onRejectedCallbacks.push((error) => {
    105.           console.log(error);
    106.           setTimeout(() => {
    107.             try {
    108.               // onRejected如果不抛出异常，则为执行态
    109.               // 比如catch回调中如果不抛出异常，那么这个catch返回的就是执行态
    110.               const x = onRejected(error);
    111.               resolvePromise(bridgePromise, x, resolve, reject);
    112.             } catch (e) {
    113.               console.log(e);
    114.               reject(e);
    115.             }
    116.           });
    117.         });
    118.       });
    120.       return bridgePromise;
    121.     }
    122.   }
    124.   catch(onRejected) {
    125.     return this.then(null, onRejected);
    126.   }
    127. }
    129. function resolvePromise(bridgePromise, x, resolve, reject) {
    130.   // 避免循环引用
    131.   if (bridgePromise === x) {
    132.     return reject(new TypeError('Circular reference'));
    133.   }
    135.   // 避免重复调用
    136.   /* 
    137.     Promise.resolve().then(() => {
    138.       return new Promise((resolve, reject) => {
    139.         resolve();
    140.         reject(); // 这种情况就要用called来避免重复调用
    141.       })
    142.     })
    144.   */
    145.   let called = false;
    147.   if (x !== null && (typeof x === 'object' || typeof x === 'function')) {
    148.     // 在取 x.then 情况下，有可能出现异常
    149.     // 需要 try catch 包裹
    150.     try {
    151.       // 具有 then 方法的对象或者函数
    152.       // 比如是个Promise实例
    153.       let then = x.then;
    154.       if (typeof then === 'function') {
    155.         // 如果 then 是一个函数
    156.         // 以 x 为 this 调用 then 函数
    157.         then.call(
    158.           x,
    159.           (y) => {
    160.             if (called) {
    161.               return;
    162.             }
    163.             called = true;
    164.             resolvePromise(bridgePromise, y, resolve, reject);
    165.           },
    166.           (r) => {
    167.             if (called) {
    168.               return;
    169.             }
    170.             called = true;
    171.             reject(r);
    172.           }
    173.         );
    174.       } else {
    175.         // 如果 then 不是函数，以 x 为参数resolve promise
    176.         // .then(res => 123).then(x => console.log(x)) 透传
    177.         resolve(x);
    178.       }
    179.     } catch (error) {
    180.       // 如果出错了也是不能继续调用resolve和reject函数
    181.       if (called) {
    182.         return;
    183.       }
    184.       called = true;
    185.       reject(error);
    186.     }
    187.   } else {
    188.     // 如果 x 不为对象或者函数，以 x 为参数执行 promise
    189.     // 设置 this.value
    190.     resolve(x);
    191.   }
    192. }
    194. MyPromise.resolve = function (value) {
    195.   if (value instanceof MyPromise) {
    196.     return value;
    197.   }
    198.   return new MyPromise((resolve, reject) => {
    199.     if (value && value.then && typeof value.then === 'function') {
    200.       setTimeout(() => {
    201.         value.then(resolve, reject);
    202.       });
    203.     } else {
    204.       resolve(value);
    205.     }
    206.   });
    207. };
    209. MyPromise.reject = function (error) {
    210.   return new MyPromise((resolve, reject) => {
    211.     reject(error);
    212.   });
    213. };
    215. MyPromise.all = function (promises) {
    216.   return new MyPromise((resolve, reject) => {
    217.     let result = [];
    218.     let count = 0; // 做个标记进行统计
    219.     for (let i = 0; i < promises.length; i++) {
    220.       promises[i].then(
    221.         function (data) {
    222.           result[i] = data;
    223.           count++;
    224.           // 在放到count为promises.length的promise的onFulfilled回调中进行resolve
    225.           // 因为count如果为promises.length，则说明所有的promise都fulfilled了
    226.           if (count === promises.length) {
    227.             resolve(result);
    228.           }
    229.         },
    230.         function (error) {
    231.           reject(error);
    232.         }
    233.       );
    234.     }
    235.   });
    236. };
    238. MyPromise.race = function (promises) {
    239.   return new MyPromise((resolve, reject) => {
    240.     for (let i = 0; i < promises.length; i++) {
    241.       promises[i].then(
    242.         // 有个promise执行态了，就直接resolve
    243.         (data) => {
    244.           resolve(data);
    245.         },
    246.         (error) => reject(error)
    247.       );
    248.     }
    249.   });
    250. };
    252. MyPromise.promisify = function (fn) {
    253.   return function (...args) {
    254.     return new MyPromise((resolve, reject) => {
    255.       fn.apply(
    256.         null,
    257.         args.concat((err) => {
    258.           err ? reject(err) : resolve(args[1]);
    259.         })
    260.       );
    261.     });
    262.   };
    263. };
    265. MyPromise.deferred = function () {
    266.   let defer = {};
    267.   defer.promise = new MyPromise((resolve, reject) => {
    268.     defer.resolve = resolve;
    269.     defer.reject = reject;
    270.   });
    271.   return defer;
    272. };
    274. module.exports = MyPromise;

    简单版

    1. function MyPromise(fn) {
    2.   this.cbs = [];
    3.   this.value = null;
    5.   const resolve = (value) => {
    6.     setTimeout(() => {
    7.       this.value = value;
    8.       this.cbs.forEach((cb) => cb(value));
    9.     });
    10.   }
    12.   fn(resolve);
    13. }
    15. MyPromise.prototype.then = function (onResolved) {
    16.   return new MyPromise((resolve) => {
    17.     this.cbs.push(() => {
    18.       const res = onResolved(this.value);
    19.       if (res instanceof MyPromise) {
    20.         res.then(resolve);
    21.       } else {
    22.         resolve(res);
    23.       }
    24.     });
    25.   });
    26. };

    https://zhuanlan.zhihu.com/p/58428287?utm_source=wechat_timeline