编辑代码

// 设计一个函数，可以限制请求的并发，同时请求结束之后，调用callback函数
// sendRequest(requestList:,limits,callback):void
sendRequest(

[()=>request('1'),

()=>request('2'),

()=>request('3'),

()=>request('4')],

3, //并发数

(res)=>{

    console.log(17,res)

})

// 其中request 可以是： 
function request (url,time=1){

    return new Promise((resolve,reject)=>{

        setTimeout(()=>{

            console.log('请求结束：'+url);

            if(Math.random() > 0.5){

                resolve('成功')

            }else{

                reject('错误;')

            }

        },time*1e3)

    })
}



/*

function sendRequest (requestList , limits , callback) {
    // console.log(49,requestList.length)
    const promises = requestList.slice() 
    const resultes = []

    const concurrentNum = Math.min(limits,promises.length) 

    let concurrentIndex = 0 

    const runTaskNeeded = () => {
        let i = 0 

        while(i < concurrentNum) {
            i ++ 
            runTask()
        }
    } ,
    runTask = () => {
        const task = promises.shift()
        task && runner(task)
    },
    runner = async (task) => {
        // console.log(69,task)
        try {
            concurrentIndex ++ 
            let result = await task()
            console.log(74,result , resultes)
            resultes.push({code:'ok',data:result})
        }catch(error) {
            console.log(77,error, resultes)
            resultes.push({code:'error',error})
        }finally {
            concurrentIndex --
            console.log(81,'next')
            next()
        }
    },
    next = () => {
        console.log(85 , promises.length, concurrentIndex)
        if(concurrentIndex < limits && promises.length > 0) {
            runTask()
        } else if(promises.length == 0 && concurrentIndex == 0) {
            callback && callback(resultes)
        }
    }
   

   runTaskNeeded()

}


*/

async function sendRequest(requestList , limits,callback) {
    const promises = [] 

    const pool = new Set() 

    for(let request of requestList) {
        if(pool.size >= limits ) {
            await Promise.race(pool).catch(err => err )
        }
        const promise = request() 

        const cb = () => {
            pool.delete(promise)
        }

        promise.then(cb,cb) 
        pool.add(promise) 
        promises.push(promise)
        console.log(121,promises)
    }

    Promise.allSettled(promises).then(callback,callback)

}