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

最新推荐文章于 2025-10-02 11:09:51 发布

原创最新推荐文章于 2025-10-02 11:09:51 发布 · 705 阅读

0 ·

CC 4.0 BY-SA版权

js 专栏收录该内容

10 篇文章

订阅专栏

本文深入解析Promise的all、race方法及其实现原理，探讨如何利用Promise进行任务的并发控制，包括限制并发数量的方法。

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 })
  );
};