33.手写 Promise

 继前文学习以后总结的手写Promise代码

function Promise(executor) {

  this.PromiseState = 'pending'
  this.PromiseResult = null
  this.callbacks = []

  const self = this

  function resolve(data) {
    if (self.PromiseState !== 'pending') return
    self.PromiseState = 'resolved'
    self.PromiseResult = data
    setTimeout(() => {
      self.callbacks.forEach(item => {
        item.onResolved(self.PromiseResult)
      })
    })
  }
  function reject(data) {
    if (self.PromiseState !== 'pending') return
    self.PromiseState = 'rejected'
    self.PromiseResult = data
    setTimeout(() => {
      self.callbacks.forEach(item => {
        item.onRejected(self.PromiseResult)
      })
    })
  }

  try {
    executor(resolve, reject)
  } catch (e) {
    reject(e)
  }
}



Promise.prototype.then = function (onResolved, onRejected) {
  const self = this

  if (typeof onRejected !== 'function') {
    onRejected = reason => {
      throw reason
    }
  }

  if (typeof onResolved !== 'function') {
    onResolved = value => value
  }
  return new Promise((resolve, reject) => {
    function callback(type) {
      try {
        let result = type(this.PromiseResult)
        if (result instanceof Promise) {
          result.then(v => {
            resolve(v)
          }, r => {
            reject(r)
          })
        } else {
          resolve(result)
        }
      } catch (e) {
        reject(e)
      }
    }
    if (this.PromiseState === 'resolved') {
      setTimeout(() => {
        callback(onResolved)
      })
    }
    if (this.PromiseState === 'rejected') {
      setTimeout(() => {
        callback(onRejected)
      })
    }
    if (this.PromiseState === 'pending') {
      this.callbacks.push({
        onResolved: function () {
          callback(onResolved)
        },
        onRejected: function () {
          callback(onResolved)
        }
      })
    }
  })
}

Promise.prototype.catch = function (onRejected) {
  return this.then(undefined, onRejected)
}

Promise.resolve = function (value) {
  return new Promise((resolve, reject) => {
    if (value instanceof Promise) {
      value.then(v => {
        resolve(v)
      }, r => {
        reject(r)
      })
    } else {
      resolve(value)
    }
  })
}

Promise.reject = function (reason) {
  return new Promise((resolve, reject) => {
    reject(reason);
  });
};

Promise.all = function (promises) {
  return new Promise((resolve, reject) => {
    let count = 0
    let arr = []
    for (let i = 0; i < promises.length; i++) {
      promises[i].then(v => {
        count++
        arr[i] = v
        if (count === promises.length) {
          resolve(v)
        }
      }, r => {
        reject(r)
      })
    }
  })
}

Promise.race = function (promises) {
  return new Promise((resolve, reject) => {
    for (let i = 0; i < promises.length; i++) {
      promises[i].then(
        (v) => {
          resolve(v);
        },
        (r) => {
          reject(r);
        }
      );
    }
  });
};