手写Promise.all

1，Promise.all是一个异步方法，返回一个Promise对象

2，Promise接收一个Promise对象数组

3，当所有promises都resolved之后，会返回一个状态为"resolved"的promise,这个promise的成功值是所有promise执行返回的结果数组

4，当有一个promise失败或者reject之后，会返回一个状态为"rejected"的promise,reject的值是这个第一个失败promise返回的值。

myPromiseAll=function(promises){
return new Promise((resolve,reject)=>{
   let result=[];
   promises.forEach(promise=>{
       promise.then((data)=>{
           result.push(data);
           if(result.length===promises.length){
               resolve(result);
           }
       },err=>{
           reject(err);
       })
   })
   var results=[];
})
}


let promise1=new Promise((resolve,reject)=>{
 resolve(111)
})
let promise2=new Promise((resolve,reject)=>{
 resolve(222)
})
let promise3=new Promise((resolve,reject)=>{
 resolve(333)
})
let promise4=new Promise((resolve,reject)=>{
 resolve(4444)
})
var promiseAll=myPromiseAll([promise1,promise2,promise3,promise4]);
promiseAll.then(data=>{
 console.log("allResolve----"+data)
},reject=>{
 console.log("reject----"+reject)
})
console.log(promiseAll)

保证promise的顺序的方法：

首先如果按照上述的写法并不能保证顺序返回结果，可以通过谢列代码进行验证：

把其中一个promise的处理过程修改一下，得到的结果很明显不是顺序输出的

let promise3 = new Promise((resolve, reject) => {
 setTimeout(() => {
     resolve(3333);
 }, 1000)
})

保证顺序方法一：用一个额外的promise对象进行控制,一个promise的执行过程赋值给这个额外的promise对象，如果想之心那个下一个promise,要保证上一个promise执行完成。

myPromiseAll = function (promises) {
 let res = [];
 let tempPromise = Promise.resolve();

 return new Promise((resolve, reject) => {
     promises.forEach((item, index) => {
         tempPromise = tempPromise.then(() => item).then(data => {
             console.log(index)
             res.push(data);
             return res;
         }).catch(e => {
             reject(e);
         })
     })
     tempPromise.then(data => {
         if (data.length === promises.length) {
             console.log(data)
         }

     })
 });
}

保证顺序方法二：利用async,await的异步方法同步处理，来达到顺序执行异步操作。

function myPromiseAll(promises) {
  return new Promise((resolve, reject) => {
      asyncx(promises, resolve, reject)
  })
}

async function asyncx(promises, resolve, reject) {
  let res = [];
  for (var i = 0; i < promises.length; i++) {
      let x = await promises[i].then(data => {
          res.push(data);
          return res;
      }, err => {
          errFlag = true;
          reject(err)
      }).catch(
          err => {
              errFlag = true;
              reject(err)
          }
      );

      if (res.length === promises.length) {
          resolve(x);
          return;
      }
  }
}