Promise之all

一，

Promise.all(iterable)查看报道方法一个解析参数中的所有承诺  都已解析或者迭代参数不所有游戏承诺  的单个解析器。它拒绝了拒绝的第一个承诺的原因。Promiseiterable

var promise1 = Promise.resolve（1）; 
var promise2 = 2; 
var promise3 = new Promise（function（resolve，reject）{ 
  setTimeout（resolve，100，'zz'）; 
}）; 

Promise.all（[promise1，promise2，promise3]），然后（函数（值）{。
  的的console.log（值）; 
}）; 
//输出：Array [1,2，“zz”];

描叙1.如果一个空的迭代被传递，那么这个方法返回（同步）一个已经解决的诺言。2. 
如果所有传入的承诺都履行或不承诺，则返回的承诺将Promise.all异步履行
3 。在所有情况下，返回的承诺都是通过一个数组实现的，该数组包含作为参数传递的所有迭代值（也是非承诺值）

4 . 拒绝：
如果任何传入的承诺拒绝，Promise.all异步拒绝拒绝承诺的价值，其他承诺是否已经解决。

例子

1. Promise.all 等待所有履行（或第一次拒绝）

var p1 = Promise.resolve（3）; 
var p2 = 1337; 
var p3 = new Promise（（resolve，reject）=> { 
  setTimeout（resolve，100，'foo'）; 
}）; 

Promise.all（[p1，p2，p3]）。然后（values => { 
  的console.log（值）; // [3,1337，“foo”] 
}）;

2. 如果迭代包含非诺值，它们将被忽略，但仍计入返回的承诺数组值（如果保证已满足）：

/ /这将被视为如果通过的迭代是空的，所以它得到满足
var p = Promise.all（[1,2,3]）; 
/ /这将被计算为如果传递的迭代包含值只有解决的承诺“444”，所以它得到满足
var p2 = Promise.all（[1,2,3，Promise.resolve（444）]）; 
//这将被视为传递的迭代只包含被拒绝的值为“555”的承诺，因此它被拒绝
var p3 = Promise.all（[1,2,3，Promise.reject（555）]）; 

//使用的setTimeout，可以我们在堆栈清空后执行代码
的的setTimeout（函数（）{ 
    的的console.log（P）; 
    的的console.log（P2）; 
    的的console.log（P3）; 
}）; 

// Promise {<state>：“fulfilled”，<value>：Array [3]} 
// Promise {<state>：“fulfilled”，<value>：Array [4]} 
// Promise {<state> “拒绝”，<原因>：555}

3.异步或者同步性Promise.all

以下示例演示了以下异步性（或同步性，如果传递的迭代是空的）Promise.all：

//我们传递一个已经解决的promise数组作为参数，
//尽快触发Promise.all 
var resolvedPromisesArray = [Promise。解决（33），Promise.resolve（44）]; 

var p = Promise.all（resolvedPromisesArray）; 
//立即记录p值的
的执行console.log（P）; 

//使用setTimeout，我们可以在堆栈清空后执行代码
的setTimeout（函数（）{ 
    console.log（'堆栈现在是空的'））
    的console.log（P）; 
}）; 

//日志，按顺序：
// Promise {<state>：“pending”} 
//堆栈现在是空的
// Promise {<state>：“ fulfilled ”，<value>：Array [2]} 
如果Promise。所有拒绝，则会发生同样的情况：

var mixedPromisesArray = [Promise.resolve（33），Promise.reject（44）]; 
var p = Promise.all（mixedPromisesArray）; 
的console.log（P）;
的setTimeout（函数（）{ 
    console.log（'堆栈现在是空的'）; 
    的console.log（P）; 
}）; 

// Promise {<state>：“pending”} 
//堆栈现在是空的
// Promise {<state>：“rejected”，<reason>：44}

4. 当传递的迭代的的英文空的时才Promise.all同步解析：

var p = Promise.all（[]）; //会立即解决
var p2 = Promise.all（[1337，“hi”]）; //非承诺值将被忽略，但评估将异步完成
的console.log（P）; 
执行console.log（P2）
的setTimeout（函数（）{ 
    console.log（'堆栈现在是空的'）; 
    的的console.log（P2）; 
}）; 

//日志
// Promise {<state>：“fulfilled”，<value>：Array [0]} 
// Promise {<state>：“pending”} //等待
//堆栈现在是空的
// Promise { <state>：“fulfilled”，<value>：Array [2]}

5，失败的行为：

  Promise.all 如果任何元素被拒绝，则被拒绝。例如，如果您在超时之后传递四个承诺，并且一个承诺立即拒绝， Promise.all 则会立即拒绝。

var p1 = new Promise（（resolve，reject）=> { 
  setTimeout（resolve，1000，'one'）; 
}）; 
var p2 = new Promise（（resolve，reject）=> { 
  setTimeout（resolve，2000，'two'）; 
}）; 
var p3 = new Promise（（resolve，reject）=> { 
  setTimeout（resolve，3000，'three'）; 
}）; 
var p4 = new Promise（（resolve，reject）=> { 
  setTimeout（resolve，4000，'four'）; 
}）; 
var p5 = new Promise（（resolve，reject）=> { 
  拒绝（'拒绝'）; 
}）; 

Promise.all（[p1，p2，p3，p4，p5]）。then（values => { 
  的console.log（值）; 
}，reason => { 
  执行console.log（理由）
}）; 

//从控制台：
//“拒绝” 

//你也可以使用.catch
Promise.all（[p1，p2，p3，p4，p5]）。then（values => { 
  的console.log（值）; 
}）。catch（reason => { 
  执行console.log（理由）
}）; 

//从控制台：
//“拒绝”