Javascript 如何在一个条件下停止js promise.all（）？

我有这段代码

 let promiseList = []

    for (let i in data) {
        let promise = checkIfMember(data[i].tg_id, chatId).then(res => {
            if (res) {
                //if the user has a undefined username it won't be rained
                if (data[i].username != "undefined") {
                    console.log(data[i].username)
                    members.push([data[i].tg_id, data[i].username])
                }
            }
        }).catch(err => {
            console.log(err)
        })
        promiseList.push(promise)
    }

    return Promise.all(promiseList).then((res) => {
        //list of members that are in the room , we randomize it before returning
        shuffleArray(members)
        if(numberOfUsers > members.length){
            return[false, members.length]
        }else{
            members = members.slice(0,numberOfUsers)
            return [true, members]
        }
    });

基本上，我有一个承诺清单正在填写中。然后，所有这些都是在一个允诺下执行的。问题是，我不想让所有人都执行，我想做这样的事情：

let promiseList = []
    let validmembers = 0;
    for (let i in data) {
        let promise = checkIfMember(data[i].tg_id, chatId).then(res => {
            if (res) {
                //if the user has a undefined username it won't be rained
                if (data[i].username != "undefined") {
                    console.log(data[i].username)
                    members.push([data[i].tg_id, data[i].username])
                    //stop there the execution
                    validmembers++;
                    if(validmembers == numberOfUsers){
                        return;
                    }
                }
            }
        }).catch(err => {
            console.log(err)
        })
        promiseList.push(promise)
    }

    return Promise.all(promiseList).then((res) => {
        //list of members that are in the room , we randomize it before returning
        shuffleArray(members)
        if(numberOfUsers > members.length){
            return[false, members.length]
        }else{
            members = members.slice(0,numberOfUsers)
            return [true, members]
        }
    });

但问题是承诺是异步的，所以承诺列表的填充并没有停止。

---

如何解决此问题？

由于承诺，您似乎希望

成员

数组中的用户数不超过

numberOfUsers

项。由于承诺是异步运行的，因此无法阻止调用

checkIfMember

函数，但在其

then

函数内部，可以避免像这样累积更多成员：

let promiseList = []
    let validmembers = 0;
    for (let i in data) {
        let promise = checkIfMember(data[i].tg_id, chatId).then(res => {
            if (res) {
                //if the user has a undefined username it won't be rained
                if (data[i].username != "undefined") {
                    console.log(data[i].username)
                    members.push([data[i].tg_id, data[i].username])
                    //stop there the execution
                    validmembers++;
                    if(validmembers == numberOfUsers){
                        return;
                    }
                }
            }
        }).catch(err => {
            console.log(err)
        })
        promiseList.push(promise)
    }

    return Promise.all(promiseList).then((res) => {
        //list of members that are in the room , we randomize it before returning
        shuffleArray(members)
        if(numberOfUsers > members.length){
            return[false, members.length]
        }else{
            members = members.slice(0,numberOfUsers)
            return [true, members]
        }
    });

//不要使用`！==“undefined”`除非它实际上可以是字符串“undefined”
如果（数据[i].用户名）{
if（members.length

当

成员尚未满时，只需按下
成员
，就可以避免添加超过
个数的用户
，以后无需执行
切片

相反，如果您希望在收集了足够的数据后避免整个promise工作，则可以按如下方式序列化它们：

let promiseList = []
    let validmembers = 0;
    for (let i in data) {
        let promise = checkIfMember(data[i].tg_id, chatId).then(res => {
            if (res) {
                //if the user has a undefined username it won't be rained
                if (data[i].username != "undefined") {
                    console.log(data[i].username)
                    members.push([data[i].tg_id, data[i].username])
                    //stop there the execution
                    validmembers++;
                    if(validmembers == numberOfUsers){
                        return;
                    }
                }
            }
        }).catch(err => {
            console.log(err)
        })
        promiseList.push(promise)
    }

    return Promise.all(promiseList).then((res) => {
        //list of members that are in the room , we randomize it before returning
        shuffleArray(members)
        if(numberOfUsers > members.length){
            return[false, members.length]
        }else{
            members = members.slice(0,numberOfUsers)
            return [true, members]
        }
    });

异步函数yourFunction（）{
for（让我输入数据）{
if（members.length{
如果（res）{
//如果用户有一个未定义的用户名，它将不会下雨
if（数据[i].username！=“未定义”）{
console.log（数据[i].username）；
push（[data[i].tg_id，data[i].username]）；
}
}
})
.catch（错误=>{
控制台日志（err）；
});
}否则{
break；//成员已满后无需继续
}
}
返回[正确，成员]；
}

promise all实际上并不执行承诺，它只向承诺添加一个包装器，一旦所有承诺都解决了，它就可以有效地不填充数组并避免切片。但是问题是执行承诺X次，我不想滥用api，这是主要问题，并且该条件仍然会执行所有承诺。我希望他们在到达treshold后停止执行。唯一的方法是序列化承诺，而不是将它们全部踢开，然后等待它们完成。在上一个任务完成后，您是否可以只启动一个任务？是的，也可以，但我真的不知道如何实现它