利用promise简单实现Promise.all()和Promise.race()

• Promise.all()方法用于将多个 Promise 实例，包装成一个新的 Promise 实例.

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

  上面代码中，Promise.all()方法接受一个数组作为参数，p1、p2、p3都是 Promise 实例，如果不是，就会先调用下面讲到的Promise.resolve方法，将参数转为 Promise 实例，再进一步处理。另外，Promise.all()方法的参数可以不是数组，但必须具有 Iterator 接口，且返回的每个成员都是 Promise 实例。

  p的状态由p1、p2、p3决定，分成两种情况。

  （1）只有p1、p2、p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1、p2、p3的返回值组成一个数组，传递给p的回调函数。

  （2）只要p1、p2、p3之中有一个被rejected，p的状态就变成rejected，此时第一个被reject的实例的返回值，会传递给p的回调函数。

  function PromiseAll (arr) {
  //PromiseAll的返回值为一个promise对象
  	return new Promise((resolve, reject) => {
  		let resArr = [];
  		for(let i = 0; i < arr.length; i++) {
  			Promise.resolve(arr[i]()).then(res => {
  				resArr.push(res);
  				//只有所有的都成功了，才会返回resolve
  				if (i == arr.length - 1) {
  					return resolve(resArr);
  				}
  			}, err => {
  				return reject(err)
  			}).catch(err => {
  				console.log(err)
  			})
  		}
  	})
  }
  

  利用promise实现并发的数量

  出处

  function limitRunTask(tasks, limit) {
  	return new Promise(function(resolve,reject){
  		let index = 0, alive = 0, finish = 0, result = [];
  		function next() {
  			if(finish >=tasks.length) {
  				resolve(result);
  				return;
  			}
  			while(alive < limit && index < tasks.length) {
  				alive++;
  				const promise = tasks[index]();
  				const curIndex = index;
  				promise.then(function(value) {
  					alive--;
  					finish++;
  					result[curIndex] = value;
  					next();
  				});
  				index++
  			}
  		}
  		next();
  	})
  }
  

• Promise.race()方法同样是将多个 Promise 实例，包装成一个新的 Promise 实例。

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

  上面代码中，只要p1、p2、p3之中有一个实例率先改变状态，p的状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给p的回调函数。

  Promise.race()方法的参数与Promise.all()方法一样，如果不是 Promise 实例，就会先调用下面讲到的Promise.resolve()方法，将参数转为 Promise 实例，再进一步处理。

  // 哪个实例获得结果最快，就返回那个结果，不管结果本身是成功还是失败；
  function PromiseRace(arr) {
  	 return new Promise((resolve,reject) => {
          let len = arr.length
          for(let i = 0; i < len; i++){
              Promise.resolve(arr[i]()).then(val => {
                  resolve(val)
              }).catch(err => {
                  reject(err)
              })
          }
      
  	})
  }
  
  

参考

• Promise.prototype.finally 实现

  Promise.prototype.finally = function (callback) {
    let P = this.constructor;
    return this.then(
      value  => P.resolve(callback()).then(() => value),
      reason => P.resolve(callback()).then(() => { throw reason })
    );
  };