摘要：的幾個(gè)擴(kuò)展總結(jié)描述和相反，當(dāng)所有的被拒絕之后，方法執(zhí)行完成的決議，如果存在一個(gè)執(zhí)行完成的決議，方法則執(zhí)行拒絕里邊的所有實(shí)例反過來就好了執(zhí)行到此執(zhí)行到此描述忽略被拒絕的，只需要有一個(gè)完成的，方法就執(zhí)行完成操作，如果全部的都被拒絕，方法執(zhí)行拒絕

和 Promise.all 相反，當(dāng)所有的promise被拒絕之后，none方法執(zhí)行完成的決議，如果存在一個(gè)promise執(zhí)行完成的決議，none方法則執(zhí)行拒絕

  Promise.none = function(promises) {
    return Promise.all(promises.map(promise => {
      return new Promise((resolve, reject) => {
        // Promise.all里邊的所有promise實(shí)例反過來就好了
        return Promise.resolve(promise).then(reject, resolve)
      })
    }))
  }

  const promisesForNoneTest1= [
    Promise.reject("1"),
    Promise.reject("2"),
    Promise.resolve("3"),
    Promise.reject("4"),
  ]
  Promise.none(promisesForNoneTest1).then(res => {
    debugger
  }, res => {
    debugger // 執(zhí)行到此
  })

  const promisesForNoneTest2= [
    Promise.reject("1"),
    Promise.reject("2"),
    Promise.reject("3"),
    Promise.reject("4"),
  ]
  Promise.none(promisesForNoneTest2).then(res => {
    debugger // 執(zhí)行到此
  }, res => {
    debugger 
  })

忽略被拒絕的promise，只需要有一個(gè)完成的promise，any方法就執(zhí)行完成操作，如果全部的promise都被拒絕，any方法執(zhí)行拒絕操作

  Promise.any = function(promises) {
    const result = []
    return Promise.all(promises.map(promise => {
      // 控制Promise.all處理的所有的promise都執(zhí)行reslove決議
      return Promise.resolve(promise).then(res => {
        // 但是只記錄實(shí)際上決議為resolve的結(jié)果值
        result.push(res)
      }, () => {
        // 防止穿透，這里可以進(jìn)行拒絕信息的返回
      }) 
    })).then(() => {
      return new Promise((resolve, reject) => {
        if (result.length > 0) resolve(result)
        else reject(result)
      })
    })
  }

  const promisesForAnyTest1= [
    Promise.reject("1"),
    Promise.resolve("2"),
    Promise.reject("3"),
    Promise.resolve("4"),
    Promise.resolve("5"),
  ]

  Promise.any(promisesForAnyTest1).then(res => {
    debugger // 執(zhí)行到此，res 為 ["2", "4", "5"]
  }, res => {
    debugger
  })

  const promisesForAnyTest2= [
    Promise.reject("1"),
    Promise.reject("2"),
    Promise.reject("3"),
    Promise.reject("4"),
    Promise.reject("5"),
  ]

  Promise.any(promisesForAnyTest2).then(res => {
    debugger 
  }, res => {
    debugger // 執(zhí)行到此
  })

類似race，但是只要有一個(gè)promise決議為完成（忽略前邊被拒絕的promise），就忽略后邊的promise

  Promise.first = function(promises) {
    return new Promise((resolve, reject) => {
      let rejectNum = 0
      promises.forEach(promise => {
        // 如果當(dāng)前 promise 決議為reslove，那就直接執(zhí)行"根promise"的resolve
        // 否則去記錄到拒絕的promise中，然后判斷全部的promise拒絕了，執(zhí)行"根promise"的reject
        Promise.resolve(promise).then(resolve, () => {
          if (++rejectNum === promises.length) {
            // 這里可以控制reject返回的信息
            reject()
          }
        })
      })
    })
  }

  const promisesForFirstTest1= [
    Promise.reject("1"),
    Promise.resolve("2"),
    Promise.reject("3"),
    Promise.resolve("4"),
  ]
  Promise.first(promisesForFirstTest1).then(res => {
    debugger // 執(zhí)行到此，res 為 "2"
  }, res => {
    debugger
  })

  const promisesForFirstTest2= [
    Promise.reject("1"),
    Promise.resolve("2"),
    Promise.reject("3"),
    Promise.resolve("4"),
  ]
  Promise.first(promisesForFirstTest2).then(res => {
    debugger 
  }, res => {
    debugger // 執(zhí)行到此
  })

在第二個(gè)方法 any 中，用到了Promise.all的方法，里邊使用Array.prototype.map方法處理了所有的的promise，當(dāng)前這個(gè)Promise.map方法則希望把他倆弄到一起

Promise.map方法希望實(shí)現(xiàn)一個(gè)處理批量異步操作的并行迭代方法，本質(zhì)上是利用Promise.all進(jìn)行二次封裝

  Promise.map = function(promises, resolveCallback, rejectCallback) {
    return Promise.all(promises.map(promise => {
      return Promise.resolve(promise).then(result => {
        return resolveCallback(result)
      }, error => {
        return Promise.reject(rejectCallback(error))
      })
    }))
  }

  const promisesForMapTest1= [
    Promise.resolve("1"),
    Promise.resolve("2"),
    Promise.resolve("3"),
    Promise.resolve("4"),
  ]

  Promise.map(promisesForMapTest1, result => {
    return result * 100
  }, result => {
    return result
  }).then(res => {
    debugger // 執(zhí)行到此，res為 [100, 200, 300, 400]
  }, res => {
    debugger
  })

  const promisesForMapTest2= [
    Promise.resolve("1"),
    Promise.resolve("2"),
    Promise.reject("3"),
    Promise.resolve("4"),
  ]

  Promise.map(promisesForMapTest2, result => {
    return result * 100
  }, result => {
    return result
  }).then(res => {
    debugger 
  }, res => {
    debugger // 執(zhí)行到此，res為 "3"
  })