Pormise

//Pormise
function MyPromise (executor) {
  var self = this
  self.status = 'pending'
  self.resolveValue = null
  self.rejectValue = null
  self.resolveCallbackList = []  //用来存储resolve的回调函数
  self.rejectCallbackList = []  //用来存储reject的回调函数

  function resolve (value) {
    if (self.status === 'pending') {
      self.status = 'Fulfilled'
      self.resolveValue = value
      self.resolveCallbackList.forEach(function (item) {
        item()
      })
    }
  }

  function reject (value) {
    if(self.status === 'pending') {
      self.status = 'Rejected'
      self.rejectValue = value
      self.rejectCallbackList.forEach(function (item) {
        item()
      })
    }
  }
  try {
    executor(resolve, reject)
  } catch (e) {
    reject(e)
  }
}
function resultIsPromise (nextValue, res, rej) {
    if(nextValue instanceof MyPromise) {
        nextValue.then(function (val) {
            res(val)
        }, function(reason) {
            rej(reason)
        })
    } else {
        res(nextValue)
    }
}
MyPromise.prototype.then = function (resolve, reject) {
  if (!resolve) {
        resolve = function(val) {
          return val
      }
  }
  if (!reject) {
        reject = function (val) {
          throw new Error(val)
      }
  }
  var self = this
  var nextPromise = new MyPromise(function(res, rej) {
    setTimeout(function() {
        if (self.status === 'Fulfilled') {
        try{
            // var newResolveVal = resolve(self.resolveValue)
            // res(newResolveVal)
            var newResolveVal = resolve(self.resolveValue)
            resultIsPromise(newResolveVal, res, rej)
        } catch(e) {
            rej(e)
            }
        }
    }, 0)

    setTimeout(function () {
        if (self.status === 'Rejected') {
        try{
            var newRejectVal = reject(self.rejectValue)
            resultIsPromise(newRejectVal, res, rej)
        } catch(e) {
            rej(e)
        }
        }
    }, 0)

    if (self.status === 'pending') {
      if(typeof resolve === 'function') {
          self.resolveCallbackList.push(function () {
              setTimeout(function() {
                  try{
                      var newResolveVal = resolve(self.resolveValue)
                      resultIsPromise(newResolveVal, res, rej)
                  } catch (e) {
                      rej(e)
                  }
              })
          })
      }
      if(typeof reject === 'function') {
          setTimeout(function () {
              self.rejectCallbackList.push(function () {
                  try{
                      var newRejectVal = reject(self.rejectValue)
                      resultIsPromise(newRejectVal, res, rej)
                  } catch(e) {
                    rej(e)
                  }
              })
          }, 0)
      }
    }
  })
  return nextPromise
}
//race
MyPromise.race = function (promises) {
  return new MyPromise(function (res, rej) {
      promises.forEach( function (item) {
          item.then(res, rej)
      })
  })
}
MyPromise.resolve = function (val) {
  return new MyPromise(function (resolve) {
      resolve(val)
  })
}
MyPromise.catch = function (val) {
  return new MyPromise(function (undefined,reject) {
      reject(val)
  })
}
MyPromise.all = function (promises) {
  return new MyPromise(function(resolve, reject){
    var countNum=0;
    var promiseNum=promises.length;
    var resolvedValue=[];
    for(var i=0;i<promiseNum;i++){
        (function(i){
            promises[i].then(function(value){
                countNum++;
                resolvedValue[i]=value;
                if(countNum===promiseNum){
                    return resolve(resolvedValue)
                }
            },function(reason){
                return reject(reason)
            })
        })(i)
    }
  })
}