1. Promise就是一个类，在执行这个类的时候需要传递一个执行器进去，执行器会立即执行
    2. Promise中有三种状态，分别为成功fulfilled、失败rejected以及等待pending
      • pending -> fulfilled
      • pending -> rejected
      • resolve：fuifilled
    3. pending -> rejected
      • resolve：fuifilled
      • reject：rejected
    4. then方法内部做的事情就判断状态，如果状态是成功则调用成功的回调函数，如果状态是失败则调用失败的回调函数，then方式是被定义在原型对象中的
    5. then成功回调有一个参数，表示成功之后的值，then失败回调有一个参数，表示失败后的原因
    6. 同一个promise对象下面的then方法是可以被调用多次的
    7. then方法是可以被链式调用的, 后面then方法的回调函数拿到值的是上一个then方法的回调函数的返回值
    1. const PENDING = "pending";
    2. const FULFILLED = "fulfilled";
    3. const REJECTED = "rejected";
    5. class MyPromise {
    6.   constructor(executor) {
    7.     try {
    8.       executor(this.resolve, this.reject);
    9.     } catch {
    10.       this.reject(e);
    11.     }
    12.   }
    14.   // promise 状态
    15.   status = PENDING;
    16.   // 成功之后的值
    17.   value = undefined;
    18.   // 失败之后的原因
    19.   reason = undefined;
    20.   // 成功回调
    21.   successCallback = [];
    22.   // 失败回调
    23.   failCallback = [];
    25.   resolve = (value) => {
    26.     // 如果状态不是等待，阻止代码向下执行
    27.     if (this.status !== PENDING) return;
    28.     // 将状态变更为成功
    29.     this.status = FULFILLED;
    30.     // 保存成功之后的值
    31.     this.value = value;
    32.     // 判断成功回调是否存在，如果存在则调用
    33.     // this.successCallback && this.successCallback(this.value)
    34.     while (this.successCallback.length) this.successCallback.shift()();
    35.   };
    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.successCallback(this.reason)
    46.     while (this.failCallback.length) this.failCallback.shift()();
    47.   };
    49.   then(successCallback, failCallback) {
    50.     successCallback = successCallback ? successCallback : value => value
    51.     failCallback = failCallback ? failCallback : reason => {throw reason}
    52.     let promise2 = new MyPromise((resolve, reject) => {
    53.       // 判断状态
    54.       if (this.status === FULFILLED) {
    55.         setTimeout(() => {
    56.           try {
    57.             let x = successCallback(this.value);
    58.             // 判断 x 的值是普通值还是promise对象
    59.             // 如果是普通值则直接调用resolve
    60.             // 如果是promise对象，查看promise对象返回的结果
    61.             // 再根据promise对象返回的结果，决定调用resolve还是调用reject
    62.             resolvePromise(promise2, x, resolve, reject);
    63.           } catch(e) {
    64.             reject(e);
    65.           }
    66.         }, 0);
    67.       } else if (this.status === REJECTED) {
    68.         setTimeout(() => {
    69.           try {
    70.             let x = failCallback(this.reason);
    71.             // 判断 x 的值是普通值还是promise对象
    72.             // 如果是普通值则直接调用resolve
    73.             // 如果是promise对象，查看promise对象返回的结果
    74.             // 再根据promise对象返回的结果，决定调用resolve还是调用reject
    75.             resolvePromise(promise2, x, resolve, reject);
    76.           } catch(e) {
    77.             reject(e);
    78.           }
    79.         }, 0);
    80.       } else {
    81.         // 等待
    82.         // 将成功回调和失败回调存储起来
    83.         this.successCallback.push(() => {
    84.           setTimeout(() => {
    85.             try {
    86.               let x = successCallback(this.value);
    87.               // 判断 x 的值是普通值还是promise对象
    88.               // 如果是普通值则直接调用resolve
    89.               // 如果是promise对象，查看promise对象返回的结果
    90.               // 再根据promise对象返回的结果，决定调用resolve还是调用reject
    91.               resolvePromise(promise2, x, resolve, reject);
    92.             } catch(e) {
    93.               reject(e);
    94.             }
    95.           }, 0);
    96.         });
    97.         this.failCallback.push(() => {
    98.           setTimeout(() => {
    99.             try {
    100.               let x = failCallback(this.reason);
    101.               // 判断 x 的值是普通值还是promise对象
    102.               // 如果是普通值则直接调用resolve
    103.               // 如果是promise对象，查看promise对象返回的结果
    104.               // 再根据promise对象返回的结果，决定调用resolve还是调用reject
    105.               resolvePromise(promise2, x, resolve, reject);
    106.             } catch(e) {
    107.               reject(e);
    108.             }
    109.           }, 0);
    110.         });
    111.       }
    112.     });
    113.     return promise2;
    114.   }
    115. }
    117. function resolvePromise(promise2, x, resolve, reject) {
    118.   if (promise2 === x) {
    119.     return reject(
    120.       new TypeError("Chaining cycle detected for promise #<Promise>")
    121.     );
    122.   }
    123.   if (x instanceof MyPromise) {
    124.     // promise 对象
    125.     // x.then(value=>resolve(value),reason=>reject(reason))
    126.     x.then(resolve, reject);
    127.   } else {
    128.     // 普通值
    129.     resolve(x);
    130.   }
    131. }
    133. module.exports = MyPromise;