Promise的api实现

Promise.resolve

Promise.resolve(value)可以将任何值转成值为value状态是fulifilled的Promise,但如果传入的值本身是Promise则会原样返回

Promise.resolve=function(value){
  if(value instanceof Promise){
    return value
  }
  return new Promise(resolve=>resolve(value))
}

Promise.reject

和Promise.resolve()类似，Promise.reject()会实例化一个rejected状态的Promise.但与Promise.resolve()不同的是，如果给Promise.reject()传递一个Promise对象，则这个对象会成为新的Promose值

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

Promise.all

Promise.all的规则：

• 传入的所有Promise都是fulfilled，则会返回由他们的值组成的状态为fulfilled的新Promise
• 只要有一个Promise是rejected，则返回rejected状态的新Promise,且它的值是第一个rejected的Promise的值
• 只要有一个Promise是pending,则返回一个pending状态的新Promise

Promise.all = function (promiseArr) {
  let index = 0
  let result = []
  return new Promise((resolve, reject) => {
    promiseArr.forEach((p, i) => {
      Promise.resolve(p).then(val => {
        index++
        result[i] = val
        if (index === promiseArr.length) {
          resolve(result)
        }
      }, err => {
        reject(err)
      })
    })
  })
}

Promise.race

Promise.race会返回一个由所有可迭代实例中第一个fuifilled或rejected的实例包装后的新实例

Promise.race = function (promiseArr) {
  return new Promise((resolve, reject) => {
    promiseArr.forEach(p => {
      Promise.resolve(p).then(val => {
        resolve(val)
      }, err => {
        reject(err)
      })
    })
  })
}

Promise.allSettled

Promise.allSettled的规则：

• 所有Promise的状态都变化了，那么新返回一个状态是fulifulled的Promise,且它的值是一个数组，数组的每项由所有Promise的值和状态组成的对象。
• 如果有一个是pending的Promise,则返回一个状态是pending的新实例

Promise.allSettled = function (promiseArr) {
  let result = []
  return new Promise((resolve, reject) => {
    promiseArr.forEach((p, i) => {
      Promise.resolve(p).then(val => {
        result.push({
          status: 'fulfilled',
          value: val
        })
        if (result.length === promiseArr.length) {
          resolve(result)
        }
      }, err => {
        result.push({
          status: 'rejected',
          reason: err
        })
        if (result.length === promiseArr.length) {
          resolve(result)
        }
      })
    })
  })
}

Promise.any

Promise.any的规则

• 空数组或者所有Promise都是rejected，则返回状态是rejected的新Promise,且值为AggregateError 的错误
• 只要有一个是fulfilled状态的，则返回第一个fulfilled的新实例
• 其他情况都会返回一个pending的新实例

Promise.any = function (promiseArr) {
  let index = 0
  return new Promise((resolve, reject) => {
    if (promiseArr.length === 0) return
    promiseArr.forEach((p, i) => {
      Promise.resolve(p).then(val => {
        resolve(val)
      }, err => {
        index++
        if (index === promiseArr.length) {
          reject(new AggregateError('All promises were rejected'))
        }
      })
    })
  })
}