一个promise面试题

Question

有一个数组，里面都是promise的实例。代码实现如下要求：每次执行数组里的前n个实例，在这n个promise实例执行完后（即这n个promise的状态都是Fulfilled或Rejected）再开始下次n个实例执行，直到数组里的实例都被执行完

Answer 1

(function (){
    let data=[1,2,3,4,5,6,7,8,9];
    let n=4;
    function executePromiseGroup(dataList,groupSize){
        let _dataList_ = [...dataList];
        let finalResultData = [];
        return new Promise((resolve,reject)=>{
            let groupIndex = 0; 
            let _next_ = (groupIndex)=>{
                let _promise_all_data_ = _dataList_.splice(0,groupSize);
                if(_promise_all_data_.length===0){
                    resolve(finalResultData);
                    return;    
                }
                Promise.all(_promise_all_data_.map((data)=>{
                        return new Promise((resolve,reject)=>{
                            setTimeout(()=>{
                                 if(data === 4){
                                    resolve('模拟异步请求发生错误啦:'+data);
                                 }else{
                                    resolve('group_index:'+groupIndex+'>>'+data);
                                 }                           
                            },100);
                            //此处处理异步请求，在此处catch异步异常情况，然后resolve
                        });
                })).then((resultDataList)=>{
                    finalResultData = finalResultData.concat(resultDataList);
                    _next_(++groupIndex);
                });
            }

            _next_(groupIndex);
        });

    }
    executePromiseGroup(data,n).then((data)=>{
        console.log(data);
    })
}());

Answer 2

切割数组 Promise.allSettled后递归直到数组为空 滴滴校招？

Answer 3

const MAX_N = 10;

let n = MAX_N;

let currentRunLen = MAX_N;

const promiseTask = (promises) => {

    if (n < currentRunLen || !promises.length) {

        return;

    }

    currentRunLen = Math.min(currentRunLen, promises.length);

    n = 0;

    promises.splice(0, currentRunLen).forEach((p) => {

        p().then((i) => {

            console.log(`resolve:${i}`);

        }).catch((i) => {

            console.log(`reject:${i}`);

        }).finally(() => {

            n += 1;

            promiseTask([...promises]);

        });
    });

};

// 测试
const promises = Array.from({ length: 20 }).map((o, i) => () => new Promise((resolve, reject) => {
    setTimeout(() => {

        if (Math.random() < 0.5) {

            resolve(i);

        } else {

            reject(i);

        }

    }, 1000);

}));

promiseTask(promises);

不知道思否这代码格式化这么回事，你复制到编辑器中格式化一下吧!!

Answer 4

楼上的 Promise.prototype.allSettle 是正解，在此接口提出之前，知乎有人讨论过这个缺陷，但是原问题的链接不好找。
可以看下 这一篇博文，虽然排版比较弱，但还是可以厘清使用 Promise.prototype.all 模拟实现 Promise.prototype.allSettle 的基本思路。