1. Promise 就是一个类 在执行这个类的时候 需要传递一个执行器进去 执行器会立即执行
      2. Promise 中有三种状态 分别为 成功 fulfilled 失败 rejected 等待 pending
      pending -> fulfilled
      pending -> rejected
      一旦状态确定就不可更改
      3. resolve和reject函数是用来更改状态的
      resolve: fulfilled
      reject: rejected
      4. then方法内部做的事情就判断状态 如果状态是成功 调用成功的回调函数 如果状态是失败 调用失败回调函数 then方法是被定义在原型对象中的
      5. then成功回调有一个参数 表示成功之后的值 then失败回调有一个参数 表示失败后的原因
      6. 同一个promise对象下面的then方法是可以被调用多次的
      7. then方法是可以被链式调用的, 后面then方法的回调函数拿到值的是上一个then方法的回调函数的返回值 ```javascript const MyPromise = require(‘./myPromise’);

    function p1 () { return new MyPromise(function (resolve, reject) { setTimeout(function () { resolve(‘p1’) }, 2000) }) } function p2 () { return new MyPromise(function (resolve, reject) { reject(‘失败’) // resolve(‘成功’);
    }) }

    p2() .then(value => console.log(value)) .catch(reason => console.log(reason))

    2. ```javascript
    3. const PENDING = 'pending'; // 等待
    4. const FULFILLED = 'fulfilled'; // 成功
    5. const REJECTED = 'rejected'; // 失败
    7. class MyPromise {
    8.   constructor (executor) {
    9.     try {
    10.       executor(this.resolve, this.reject)
    11.     } catch (e) {
    12.       this.reject(e);
    13.     }
    14.   }
    15.   // promsie 状态 
    16.   status = PENDING;
    17.   // 成功之后的值
    18.   value = undefined;
    19.   // 失败后的原因
    20.   reason = undefined;
    21.   // 成功回调
    22.   successCallback = [];
    23.   // 失败回调
    24.   failCallback = [];
    26.   resolve = value => {
    27.     // 如果状态不是等待 阻止程序向下执行
    28.     if (this.status !== PENDING) return;
    29.     // 将状态更改为成功
    30.     this.status = FULFILLED;
    31.     // 保存成功之后的值
    32.     this.value = value;
    33.     // 判断成功回调是否存在 如果存在 调用
    34.     // this.successCallback && this.successCallback(this.value);
    35.     while(this.successCallback.length) this.successCallback.shift()()
    36.   }
    37.   reject = reason => {
    38.     // 如果状态不是等待 阻止程序向下执行
    39.     if (this.status !== PENDING) return;
    40.     // 将状态更改为失败
    41.     this.status = REJECTED;
    42.     // 保存失败后的原因
    43.     this.reason = reason;
    44.     // 判断失败回调是否存在 如果存在 调用
    45.     // this.failCallback && this.failCallback(this.reason);
    46.     while(this.failCallback.length) this.failCallback.shift()()
    47.   }
    48.   then (successCallback, failCallback) {
    49.     // 参数可选
    50.     successCallback = successCallback ? successCallback : value => value;
    51.     // 参数可选
    52.     failCallback = failCallback ? failCallback: reason => { throw reason };
    53.     let promsie2 = new MyPromise((resolve, reject) => {
    54.       // 判断状态
    55.       if (this.status === FULFILLED) {
    56.         setTimeout(() => {
    57.           try {
    58.             let x = successCallback(this.value);
    59.             // 判断 x 的值是普通值还是promise对象
    60.             // 如果是普通值 直接调用resolve 
    61.             // 如果是promise对象 查看promsie对象返回的结果 
    62.             // 再根据promise对象返回的结果 决定调用resolve 还是调用reject
    63.             resolvePromise(promsie2, x, resolve, reject)
    64.           }catch (e) {
    65.             reject(e);
    66.           }
    67.         }, 0)
    68.       }else if (this.status === REJECTED) {
    69.         setTimeout(() => {
    70.           try {
    71.             let x = failCallback(this.reason);
    72.             // 判断 x 的值是普通值还是promise对象
    73.             // 如果是普通值 直接调用resolve 
    74.             // 如果是promise对象 查看promsie对象返回的结果 
    75.             // 再根据promise对象返回的结果 决定调用resolve 还是调用reject
    76.             resolvePromise(promsie2, x, resolve, reject)
    77.           }catch (e) {
    78.             reject(e);
    79.           }
    80.         }, 0)
    81.       } else {
    82.         // 等待
    83.         // 将成功回调和失败回调存储起来
    84.         this.successCallback.push(() => {
    85.           setTimeout(() => {
    86.             try {
    87.               let x = successCallback(this.value);
    88.               // 判断 x 的值是普通值还是promise对象
    89.               // 如果是普通值 直接调用resolve 
    90.               // 如果是promise对象 查看promsie对象返回的结果 
    91.               // 再根据promise对象返回的结果 决定调用resolve 还是调用reject
    92.               resolvePromise(promsie2, x, resolve, reject)
    93.             }catch (e) {
    94.               reject(e);
    95.             }
    96.           }, 0)
    97.         });
    98.         this.failCallback.push(() => {
    99.           setTimeout(() => {
    100.             try {
    101.               let x = failCallback(this.reason);
    102.               // 判断 x 的值是普通值还是promise对象
    103.               // 如果是普通值 直接调用resolve 
    104.               // 如果是promise对象 查看promsie对象返回的结果 
    105.               // 再根据promise对象返回的结果 决定调用resolve 还是调用reject
    106.               resolvePromise(promsie2, x, resolve, reject)
    107.             }catch (e) {
    108.               reject(e);
    109.             }
    110.           }, 0)
    111.         });
    112.       }
    113.     });
    114.     return promsie2;
    115.   }
    116.   finally (callback) {
    117.     return this.then(value => {
    118.       return MyPromise.resolve(callback()).then(() => value);
    119.     }, reason => {
    120.       return MyPromise.resolve(callback()).then(() => { throw reason })
    121.     })
    122.   }
    123.   catch (failCallback) {
    124.     return this.then(undefined, failCallback)
    125.   }
    126.   static all (array) {
    127.     let result = [];
    128.     let index = 0;
    129.     return new MyPromise((resolve, reject) => {
    130.       function addData (key, value) {
    131.         result[key] = value;
    132.         index++;
    133.         if (index === array.length) {
    134.           resolve(result);
    135.         }
    136.       }
    137.       for (let i = 0; i < array.length; i++) {
    138.         let current = array[i];
    139.         if (current instanceof MyPromise) {
    140.           // promise 对象
    141.           current.then(value => addData(i, value), reason => reject(reason))
    142.         }else {
    143.           // 普通值
    144.           addData(i, array[i]);
    145.         }
    146.       }
    147.     })
    148.   }
    149.   static resolve (value) {
    150.     if (value instanceof MyPromise) return value;
    151.     return new MyPromise(resolve => resolve(value));
    152.   }
    153. }
    155. function resolvePromise (promsie2, x, resolve, reject) {
    156.   if (promsie2 === x) {
    157.     return reject(new TypeError('Chaining cycle detected for promise #<Promise>'))
    158.   }
    159.   if (x instanceof MyPromise) {
    160.     // promise 对象
    161.     // x.then(value => resolve(value), reason => reject(reason));
    162.     x.then(resolve, reject);
    163.   } else {
    164.     // 普通值
    165.     resolve(x);
    166.   }
    167. }
    169. module.exports = MyPromise;