JavaScript————Promise（二）静态方法

Promise.all( )

promise.all([ promise1 ， promise2 ， promise3 ]),接收一个数组，元素通常是Promise对象，也可能是其他值并且返回一个promise。
当所有的实例都成功执行之后，才会执行其成功结果。当其中有一个实例失败了，整个Promise.all的结果都会变成失败

let promise1 = new Promise((res,rej) =>{res(100)});
let promise2 = new Promise((res,rej) =>{res(200)});
let promise3 = new Promise((res,rej) =>{res(300)});
Promise.all([promise1,promise2,promise3]).then(res => {
    console.log(res);
}).catch(err => {
    console.log(err);
})

// [100, 200, 300]

const promise11 = Promise.resolve(3);
const promise22 = 42;
const promise33 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
});

Promise.all([promise11, promise22, promise33]).then((values) => {
  console.log(values);
});

//  [3, 42, 'foo']

Promise.race（）

Promise.race(iterable)方法返回一个promise，一旦迭代器中的某个promise成功或失败，返回的promise就会成功或失败。

const p = Promise.race([p1,p2,p3]);

上面代码中，只要p1,p2,p3中有一个实例率先改变状态，那么p的状态也会跟着改变。也就是说，如果p1率先改变，p1成功，则p1实例的返回值就传递给p。如果p1失败，那么p的状态也会变为rejected。

率先改变的状态为成功

function promiseResolve(val) {
    return new Promise((resolve) =>{
        setTimeout(() => {
            resolve(val);
        },val*1000);
    });
}
function promiseReject(val) {
    return new Promise((reject) =>{
        setTimeout(() => {
            reject(val);
        },val*1000);
    });
}   

console.time("Promise.race");
var promiseArray = [];
promiseArray.push(promiseResolve(4));
promiseArray.push(promiseResolve(3));
promiseArray.push(promiseResolve(2));
promiseArray.push(promiseReject(3));
promiseArray.push(promiseResolve(4));
var promiseRace = Promise.race(promiseArray);
promiseRace.then(function(values) {
    console.timeEnd("Promise.race");
    console.log("率先改变的Promise",values);
});
promiseRace.catch(function(reason) {
    console.timeEnd("promise.race");
    console.log("其中一个promise失败了，原因如下" ,reason);
});

所有的promise都是并行运行的。通过上面的例子打印的时间我们也可以看到，最快的promise实例需要打印的时间为2s，第三个promise在2s内完成，所以最先改变的就返回给Promise.race。

率先改变的状态为失败

function promiseResolve(val) {
    return new Promise((resolve,reject) =>{
        setTimeout(() => {
            resolve(val);
        },val*1000);
    });
}
function promiseReject(val) {
    return new Promise((resolve,reject) =>{
        setTimeout(() => {
            reject(val);
        },val*1000);
    });
}   

console.time("Promise.race");
var promiseArray = [];
promiseArray.push(promiseResolve(4));
promiseArray.push(promiseResolve(5));
promiseArray.push(promiseResolve(6));
promiseArray.push(promiseReject(3));
promiseArray.push(promiseResolve(4));
var promiseRace = Promise.race(promiseArray);
promiseRace.then(function(values) {
    console.timeEnd("Promise.race");
    console.log("率先状态为resolve的Promise",values);
}).catch(function(reason) {
    console.timeEnd("promise.race");
    console.log("率先状态为reject的promise" ,reason);
});

所有的promise都是并行运行。第四个promise在3s内完成，所以是最先改变的居返回给promise.race。