Promise的static方法汇总

Promise.resolve

Promise.resolve()方法返回一个以给定值解析后的Promise对象。如果这个值是一个 promise，那么将返回这个 promise；如果这个值是thenable（即带有"then"方法），返回的promise会“跟随”这个thenable的对象，采用它的最终状态。

const thenable = {
  then(onFullfilled, onRejected) {
    onFullfilled("thenable");
    throw new Error("error thenable"); // 不会改变为rejected状态
  }
};
const errorThenable = {
  then(onFullfilled, onRejected) {
    throw new Error("error thenable");
    onFullfilled("thenable"); // 不会改变为fullfilled状态
  }
};
//参数为空
Promise.resolve().then(function(value) {
  console.log(value);    //undefined
});
//参数为非thenable
Promise.resolve("string").then(function(value) {
  console.log(value);    //"string"
});
//参数为fullfilled thenable
Promise.resolve(thenable).then(function(value) {
  console.log(value);    //"thenable"
});
//参数为rejected thenable
Promise.resolve(errorThenable).catch(function(value) {
    console.log(value);  //"error thenable"
})
//参数为Promise
Promise.resolve(new Promise(function(resolve) {
  resolve("Promise");
})).then(function(value) {
  console.log(value);    //"Promise"
});

Promise.reject

Promise.reject()方法返回一个带有拒绝原因的Promise对象。

Promise.all

Promise.all()方法接收一个Promise的iterable类型（注：Array，Map，Set都属于ES6的iterable类型）的输入，并且只返回一个Promise实例； Promise.all的resolve回调的结果是一个数组，这个Promise的resolve回调在所有输入的Promise的resolve回调都结束，或者输入的iterable里没有promise了的时候执行。它的reject回调执行是，只要任何一个输入的Promise的reject回调执行或者输入不合法的Promise就会立即抛出错误，并且reject的是第一个抛出的错误信息。

const p1 = Promise.resolve(3);
const p2 = 1337;
const p3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
});

// 等待所有都完成，或其中任意一个失败后返回。
Promise.all([p1, p2, p3]).then(values => {
  console.log(values); // [3, 1337, "foo"]
});

Promise.all(0).catch(err => {
    console.log(err) // TypeError: number 0 is not iterable
});

Promise.allSettled (ES11)

Promise.allSettled()方法在所有给定的Promise都已完成（不论fulfilled或rejected）后返回一个fulfilled状态的promise，并带有一个对象数组，每个对象表示对应的promise结果。
数组类型: { status: string, value: any }。

const promise1 = Promise.resolve(3);
const promise2 = new Promise((resolve, reject) => setTimeout(reject, 100, 'foo'));
const promises = [promise1, promise2];

Promise.allSettled(promises).then((results) => console.log(results));

// [{
//     status: "fulfilled",
//     value: 3
// }, {
//     statues: "rejected",
//     reason: "foo"
// }]

Promise.race

Promise.race(iterable)方法返回一个 promise，一旦iterable中的某个Promise解决或拒绝，返回的 Promise就会解决或拒绝。如果传的iterable是空的，则返回的 Promise 将永远等待。如果迭代包含一个或多个非承诺值或已解决/拒绝的承诺，则 Promise.race 将解析为迭代中找到的第一个值。

var p1 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 500, "one");
});
var p2 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 100, "two");
});
Promise.race([p1, p2]).then(function(value) {
  console.log(value); // "two"
  // 两个都完成，但 p2 更快
});


var p3 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 100, "three");
});
var p4 = new Promise(function(resolve, reject) {
    setTimeout(reject, 500, "four");
});
Promise.race([p3, p4]).then(function(value) {
  console.log(value); // "three"
  // p3 更快，所以它完成了
}, function(reason) {
  // 未被调用
});


var p5 = new Promise(function(resolve, reject) {
    setTimeout(resolve, 500, "five");
});
var p6 = new Promise(function(resolve, reject) {
    setTimeout(reject, 100, "six");
});
Promise.race([p5, p6]).then(function(value) {
  // 未被调用
}, function(reason) {
  console.log(reason); // "six"
  // p6 更快，所以它失败了
});

const raceArr = [22, Promise.resolve(33), Promise.resolve(44)];

// 因为22为非Promise值，所以返回22
Promise.race(raceArr).then(val => console.log(val)); // 22

Promise.any (ES12)

Promise.any()接收一个Promise可迭代对象，只要其中的一个 Promise 成功，就返回那个已经成功的 Promise 。如果可迭代对象中没有一个 Promise 成功（即所有的 promises 都失败/拒绝），就返回一个失败的 Promise和AggregateError类型的实例，它是Error的一个子类，用于把单一的错误集合在一起。本质上，这个方法和Promise.all()是相反的。

// 成功情况
const pErr = new Promise((resolve, reject) => {
  reject("总是失败");
});

const pSlow = new Promise((resolve, reject) => {
  setTimeout(resolve, 500, "最终完成");
});

const pFast = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, "很快完成");
});

Promise.any([pErr, pSlow, pFast]).then((value) => {
  console.log(value); // 很快完成
})



// 失败情况
const pErr = new Promise((resolve, reject) => {
  reject('总是失败');
});

Promise.any([pErr]).catch((err) => {
  console.log(err);
})
// 期望输出: "AggregateError: No Promise in Promise.any was resolved"