Promise.all()

Promise.all([Promise数组：「要求数组中的每一项尽可能都是Promise实例」])：返回一个新的Promise实例AA,
AA成功还是失败，取决于数组中的每一个Promise实例是成功还是失败，只要有一个失败，AA就是失败的，只有都成功AA才是成功的。
使用场景：并行，初始化同时发送多个请求，等所有信息都请求回来后，做处理
并行：10个请求都成功后，在做处理叫并行，速度快
串行：第一个请求成功才能发第二个，第二个请求成功后才能发第三个

  1. function fn(interval){
  2.     return new Promise((resolve, reject)=>{
  3.       setTimeout(()=>{
  4.         resolve(interval)
  5.     },interval)
  6.   })
  7. }
  9. let p1 = fn(3000)
  10. let p2 = fn(1000)
  11. let p3 = Promise.resolve(0)
  13. Promise.all([]).then(result =>{
  14.   // 不论谁先知道状态，最后结果的顺序和传递数组的顺序保持一致
  15.   console.log(result)
  16. }.catch(reason =>{
  17.   // 处理过程中，遇到一个失败，则all立即为失败，结果就是当前实例失败的原因
  18.   console.log(reason)
  19. }))
  21. // 需求实例：
  22. // api1，api2，api3  api1的返回结果作为api2的的请求实例，api2作为api3的请求实例
  23. // 基于Promise
  25. const api1 = () =>{
  26.     return new Promise(resolve =>{
  27.       $.ajax({
  28.         url: '/api1',
  29.       auccess(result1){
  30.           resolve(result1)
  31.       }
  32.     })
  33.   })
  34. }
  35. const api2 = () =>{
  36.     return new Promise(resolve =>{
  37.       $.ajax({
  38.         url: '/api2',
  39.       auccess(result2){
  40.           resolve(result2)
  41.       }
  42.     })
  43.   })
  44. }
  45. const api2 = () =>{
  46.     return new Promise(resolve =>{
  47.       $.ajax({
  48.         url: '/api2',
  49.       auccess(result3){
  50.           resolve(result3)
  51.       }
  52.     })
  53.   })
  54. }
  56. // 串行请求
  57. api1.then(result1 =>{
  58.     return api2()
  59. }).then(result2 =>{
  60.     retuen api3()
  61. }).then(result3 =>{
  63. })
  65. // 并行请求
  66. Promise.all([api1(), api2(), api3()]).then(result =>{
  68. })
  70. // es7 async await 串行 异步请求
  71. (async function(){
  72.     let result1 = await api1();
  73.   let result2 = await api2();
  74.   let result3 = await api3();
  75. })()

Promise.race

最先知道状态的Promise实例是成功还是失败，决定了AA是成功还是失败
使用场景：需要向10个接口发请求，哪一个访问最快就优先以谁处理