手写promise

promise规范

1、当实例化Promise时会立即执行

2、已经是成功态或是失败态不可再更新状态

3、让Promise支持异步

我们可以参照发布订阅模式，在执行then方法时如果还在等待态（pending），就把回调函数临时寄存到一个数组里，当状态发生改变时依次从数组中取出执行就好了。

4、链式调用

5、每个then方法都返回一个新的Promise对象（原理的核心）

6、如果then方法中显示地返回了一个Promise对象就以此对象为准，返回它的结果

7、如果then方法中返回的是一个普通值（如Number、String等）就使用此值包装成一个新的Promise对象返回。

8、如果then方法中没有return语句，就视为返回一个用Undefined包装的Promise对象

9、若then方法中出现异常，则调用失败态方法（reject）跳转到下一个then的onRejected

10、如果then方法没有传入任何回调，则继续向下传递（值的传递特性）。

function _Promise(executor){
      var _this = this;
      this.status = 'pending';      //status属性保存了Promise对象的状态
      this.value = undefined;       //一个Promise对象执行成功了要有一个结果，它使用value属性保存
      this.reason = undefined;      //也有可能由于某种原因失败了，这个失败原因放在reason属性中保存
      this.onFulfilledFunc = [];   //保存成功回调
      this.onRejectedFunc = [];    //保存失败回调
      executor(resolve, reject);    //其执行器函数（executor）会立即执行

      //当Promise对象已经由pending状态改变为了成功态（resolved）或是失败态（rejected）就不能再次更改状态了
      function resolve(value){  
          if(_this.status === 'pending'){
            _this.value = value;//保存成功结果
            _this.onFulfilledFunc.forEach(fn=>fn(value));
            _this.status = 'resolved';
          }
      }

      function reject(reason){
          if (_this.status === 'pending') {
            _this.value = reason;//保存失败原因
            _this.onRejectedFunc.forEach(fn=>fn(value));
            _this.status = 'reject';
          }
      }
    }

    _Promise.prototype.then = function(onFulfilled,onRejected){
      console.log(onFulfilled)
      console.log(this)

      //不论何种情况then都返回Promise对象，所以我们就实例化一个新re_promise并返回
      var re_promise = new _Promise(
          (resolve,reject)=>{
              //等待态，此时异步代码还没有走完
          if (this.status === 'pending') {
            if (typeof onFulfilled === 'function') {
              this.onFulfilledFunc.push(()=>{
                setTimeout(()=>{
                  try{
                    let x = onFulfilled(this.value);
                    resolvePromise(re_promise, x, resolve, reject)
                  }
                  catch(e){
                    reject(e)
                  }
                },0)
              });

            }

            if (typeof onRejected === 'function') {
              this.onRejectedCallbacks.push(() => {
                setTimeout(() => {
                  try {
                    let x = onRejected(this.reason);
                    resolvePromise(re_promise, x, resolve, reject);
                  } catch (e) {
                    reject(e);
                  }
                }, 0)
              });

            }
          }

          if (this.status === 'resolved') {
            //判断参数类型,是函数再执行
            console.log(typeof onFulfilled)
            if (typeof onFulfilled === 'function') {
              setTimeout(() => {
                try {
                  let x = onFulfilled(this.value);
                  resolvePromise(re_promise, x, resolve, reject);
                } catch (e) {
                  reject(e);
                }
              }, 0);
            }
          }
          if (this.status === 'rejected') {
            //判断参数类型,是函数再执行
            if (typeof onRejected === 'function') {
              setTimeout(() => {
                try {
                  let x = onRejected(this.reason);
                  resolvePromise(re_promise, x, resolve, reject);
                } catch (e) {
                  reject(e);
                }
              }, 0);
            }
          }
          }
      )

      //接下来就处理根据上一个then方法的返回值来生成新Promise对象
      /**
       * 解析then返回值与新Promise对象
       * @param {Object} re_promise 新的Promise对象 
       * @param {*} x 上一个then的返回值
       * @param {Function} resolve re_promise的resolve
       * @param {Function} reject re_promise的reject
       */
      function resolvePromise(re_promise,x,resolve,reject){
        if (re_promise === x) {
          //不能返回自己的promise对象
          reject(new TypeError('Promise发生了循环引用'));
        }
        if(x !== null && (typeof x ==='object' || typeof x ==='function')){
          try{
            let then = x.then; //取出then方法引用
            if(typeof then === 'function'){
              //如果then,则认为then为一个promise对象
              let y = then.call(x, (y) => {
                //递归调用，传入y若是Promise对象，继续循环
                resolvePromise(re_promise,y,reslove,reject);
              }, (r) => {
                reject(r);
              });
            }
            else{
              resolve(x)
            }
          }catch(e){
            //防止出现取then时报错，例如使用Object.defineProperty()
            reject(e)
          }
        }
        else{
          resolve(x);
        }
      }

      return re_promise
    }

    //可是还有一个很大的问题，目前此Promise还不支持异步代码，如果Promise中封装的是异步操作，then方法无能为力：
    let p = new _Promise((resolve, reject) => {
        // resolve('同步');
        setTimeout(() => {
          resolve('异步');
        },1500);
      })
      // }).then(data=>console.log(data));

      // p.then(data => console.log(data)); //没有任何结果
      // p.then(function(data){
      //   console.log(data)
      // }); //没有任何结果

      p.then(data => {return 2;}).then(data=>{
        console.log(data)
      });