用Promise解决并发

前提

假设有两个或多个网络请求函数

如果使用asyn/await，假设一个请求需要2s，那么总共需要4s

如果使用并发，则两秒即可完成两个请求

const getA => () {
    return Promise((resolve, reject) => {
        setTimeout(() => {
          reject('reject')
        }, 2000)
    })
}

const getB => () {
    return Promise((resolve, reject) => {
        setTimeout(() => {
          resolve('resolve')
        }, 2100)
    })
}

Promise.all()

 Promise.all() 静态方法接受一个 Promise 可迭代对象作为输入，并返回一个 Promise。当所有输入的 Promise 都被兑现时，返回的 Promise 也将被兑现（即使传入的是一个空的可迭代对象），并返回一个包含所有兑现值的数组。如果输入的任何 Promise 被拒绝，则返回的 Promise 将被拒绝，并带有第一个被拒绝的原因。

简单来说：全部Promise是成功的则返回所有Promise，如果存在一个被拒绝的则返回被拒绝的Promise

async function getData() {
  const [A, B] = await Promise.all([
    getA(),
    getB()
  ])
  console.log('getData', A, B) //reject
}

 Promise.race()

Promise.race() 静态方法接受一个 promise 可迭代对象作为输入，并返回一个 Promise。这个返回的 promise 会随着第一个 promise 的敲定而敲定。

简单来说：只返回第一个返回结局的Promise，无论成功与否

async function getData() {
  const race = Promise.race([
    getA(),
    getB()
  ])
  try {
    const result = await race
    console.log('result', race)
  } catch (err) {
    console.log('err', err) // reject
  }
}

Promise.any()

Promise.any() 静态方法将一个 Promise 可迭代对象作为输入，并返回一个 Promise。当输入的任何一个 Promise 兑现时，这个返回的 Promise 将会兑现，并返回第一个兑现的值。当所有输入 Promise 都被拒绝（包括传递了空的可迭代对象）时，它会以一个包含拒绝原因数组的AggregateError拒绝。

简单来说：返回第一个成功的Promise，即使在这之前有被拒绝的Promise出现。如果全都被拒绝则返回一个拒绝Promise数组

const anyPromise = Promise.any([
    getA().catch(reject),
    getB().catch(reject)
])

Peomise.allSettled()

Promise.allSettled() 静态方法将一个 Promise 可迭代对象作为输入，并返回一个单独的Promise。当所有输入的 Promise 都已敲定时（包括传入空的可迭代对象时），返回的 Promise 将被兑现，并带有描述每个 Promise 结果的对象数组。

简单来说：每个Promise互不依赖，将会返回所有Promise结果，无论成功与否

async function getData() {
  const [A, B] = await Promise.allSettled([
    getA(),
    getB()
  ])
  console.log('data', A, B)
}