Promise的静态方法

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第22天，点击查看活动详情

resolve

Promise.resolve('foo')
// 等价于
new Promise(resolve => resolve('foo'))

• 如果参数是 Promise 实例，那么Promise.resolve将不做任何修改、原封不动地返回这个实例。
• thenable对象指的是具有then方法的对象,Promise.resolve方法会将这个对象转为 Promise 对象，然后就立即执行thenable对象的then方法
• 如果参数是一个原始值，或者是一个不具有then方法的对象，则Promise.resolve方法返回一个新的 Promise 对象，状态为resolved。

reject

等同resolve,不过结果是reject

race

Promise.race()方法接收一个数组，如果数组元素不是promise对象，会包装成Promise.resolve(元素)，返回第一个状态变化的实例的返回值，无论成功或者失败，速度最快的就行，当速度理论上相同时，数组前面的优先级大于后面的。

 const p3 = new Promise((res, reject) => {
  setTimeout(() => {
      reject('san')
  }, 200)
})

Promise.race( [Promise.resolve(5), Promise.resolve(2),p3]).then(res => {
  console.log(res);// 5
}, err => {
  console.log(err)
})
// 同速度优先级按顺序排
Promise.race( [Promise.resolve(2),Promise.resolve(5), p3]).then(res => {
  console.log(res);// 2
}, err => {
  console.log(err)
})

速度优先，不看结果

 const p1 = new Promise(res => {
    setTimeout(() => {
        res('ok')
    }, 1000)
})
const p2 = new Promise(res => {
    setTimeout(() => {
        res('no')
    }, 500)
})
const p3 = new Promise((res, reject) => {
    setTimeout(() => {
        reject('san')
    }, 200)
})
 const p4 = new Promise((res, reject) => {
    setTimeout(() => {
        res('si')
    }, 100)
})

Promise.race([p1, p2, p3]).then(res => {
    console.log(res);
}, err => {
    console.log(err, 33) // 执行这里  san
})
 Promise.race([p1, p2, p3,p4]).then(res => {
    console.log(res); // 执行这里  si
}, err => {
    console.log(err, 33) 
})

经典场景

因为fetch没有内置超时取消功能，可以利用race,来实现网络请求超过10秒后按失败处理。并终止请求

const p = Promise.race([
  fetch(url),
  new Promise(function (resolve, reject) {
    setTimeout(() => reject(new Error('request timeout')), 10000)
  })
]);
p.then(response => console.log(response)); // 如果10秒内有结果走这里
p.catch(error => console.log(error));  // 10秒内无响应走这里

all

静态方法 Promise.all() 的入参是一个数组,数组中非promise元素,会通过 Promise.resolve() 转换为 Promise 对象，返回值是一个promise对象， 如果这些 Promise 对象一部分的状态是 pending，一部分的状态是 resolved，那 res 的状态保持 pending； 当数组中有一个promise状态变成rejected，结果就是这个promise对象的结果， 当所有的promise对象的状态全部resovlved时，结果是所有promise对象的resovle参数组成的数组，

 const p1 = new Promise(res => {
     setTimeout(() => {
         res('ok')
     }, 1000)
 })
 const p2 = new Promise((res, reject) => {
     setTimeout(() => {
         res('no')
     }, 500)
 })
 const p3 = new Promise((res, reject) => {
     setTimeout(() => {
         reject('san')
     }, 200)
 })
  const p4 = new Promise((res, reject) => {
     setTimeout(() => {
         res('san')
     }, 200)
 })

 Promise.all([p1, p2, p3]).then(res => {
     console.log(res);
 }, err => {
     console.log(err) //san
 })

 Promise.all([p1, p2, p4]).then(res => {
     console.log(res);  // [ 'ok', 'no', '1212' ]
 }, err => {
     console.log(err) //san
 })

allSettled

静态方法 Promise.allSettled() 的入参是一个数组,数组中非promise元素,会通过 Promise.resolve() 转换为 Promise 对象，返回值是一个promise对象， 所有这些 Promise 对象的状态不是 pending 时， res 的状态变为 resolved，res 的结果是一个数组，数组成员就是 reason入参的 Promise 对象和status promise的最终状态。

allSettled不会被rejected,因为它不关注promise的最终状态是rejected还是resolved,只要状态从pending变成这两个任何一个就行,如果有任何一个不会有结果，那么allSettled也不会有结果

 const p1 = new Promise((res, reject) => {
     setTimeout(() => {
         reject('ok')
     }, 1000)
 })
 const p2 = new Promise((res, reject) => {
     setTimeout(() => {
         res('no')
     }, 500)
 })

 const p4 = new Promise((res, reject) => {
     setTimeout(() => {
         reject('1212')
     }, 200)
 })

 Promise.allSettled([p1, p2, p4]).then(res => {
     console.log(res);
 })
//  [
//     { status: 'rejected', reason: 'ok' },
//     { status: 'fulfilled', value: 'no' },
//     { status: 'rejected', reason: '1212' }
//   ]

any

静态方法 Promise.any() 的入参是一个数组,数组中非promise元素,会通过 Promise.resolve() 转换为 Promise 对象，返回值是一个promise对象，

promise.any的状态为这些 Promise 对象中第一个状态变为 resolved 的 Promise 对象的状态； 如果promise全是rejected，那么失败回掉函数中错误参数值为[AggregateError: All promises were rejected]