Javascript 节点-在触发下一个api调用之前，等待一个api调用完成

我正在我的一条添加用户的路线中发出POST请求。我创建了一个名为success的数组。一旦请求返回响应，我想触发下一个API调用

它目前不起作用，因为我认为我正在立即发送太多的API请求。我认为解决方案是等待第一个响应返回响应并完成，然后触发下一个API调用

这个假设正确吗？如果是的话，有谁能建议如何实施？我曾尝试在（'end'…

请看下面我的代码

app.get('/add-users', function (req, res) {

    var success = [];
    var count = 0;
    for(var i = 0; i < users.length; i++) {
        var name = users[i].userId;
        request({
            url: url,
            headers: {
                'Authorization': 'Bearer ' + users[i].accessToken,
                'Content-Type': 'application/json'
            },
            method: 'PUT',
            json: true
        }, function(err, resp, body){
            if (!err && resp.statusCode === 200) {
                success.push(name);
            }
        })
        .on('end', function(){
            console.log('this is the end');
            count++;
            if(count === users.length) {
                res.json(success);
            }
        });
    }
});

app.get（'/addusers'，函数（req，res）{
var成功=[]；
var计数=0；
对于（var i=0；i

以下是我通常将多个请求链接在一起的方式。尝试在循环中调用异步函数不会像编写代码那样有效。相反，我建议在初始请求的回调中调用下一个请求

//set index
var index = 0;
function callAPI(user) {
    //increment index
    index++
    request({request:object},function(err, res){
      if (index <= users.length) {
        callAPI(users[index])
      }
    });
}
//call function with 0 index
callApi(users[0])

//设置索引
var指数=0；
函数callAPI（用户）{
//增量指数
索引++
请求（{request:object}，函数（err，res）{
if（indexClassic！我在第一次处理node时也遇到过这个问题

让我先复制代码的某些部分来解释：

app.get('/add-users', function (req, res) {
    // [...]
    for(/* user in users */) {
        request(/* [...] */)
        .on('end', function(){
            console.log('this is the end');
            count++;
            if(count === users.length) {
                res.json(success);
            }
        });
    }
});

与其他语言（如Ruby）不同，Node不执行非阻塞I/O。这意味着它几乎以异步方式执行所有I/O操作（如发出HTTP请求）。本质上，当您启动请求时，它不会等待响应

在您的循环中，这意味着它将一个接一个地激发所有请求，而无需等待它们的响应：

start loop
  make request
  make request
  make request
end of loop

... a little later
handle response
handle response
handle response

我假设你想要的是这样的：

start loop
  make request
  handle response
  make request
  handle response
  make request
  handle response
end of loop

function getAllUsers(users) {
    function getOneUser(users) {
        let user = users.pop();
        request(/* [...] */)
            .on('end', function() {
                console.log("done with ONE user");
                if(users.length) { // do we still have users to make requests?
                    getOneUser(users); // recursion
                } else {
                    console.log("done with ALL users");
                    res.json(success);
                }
            });
    }

    // make a copy of the original users Array because we're going to mutate it
    getOneUser(Array.from(users)); 
}

我发现绕过节点的非阻塞性质并执行顺序请求的一个技巧是编写如下递归函数：

start loop
  make request
  handle response
  make request
  handle response
  make request
  handle response
end of loop

function getAllUsers(users) {
    function getOneUser(users) {
        let user = users.pop();
        request(/* [...] */)
            .on('end', function() {
                console.log("done with ONE user");
                if(users.length) { // do we still have users to make requests?
                    getOneUser(users); // recursion
                } else {
                    console.log("done with ALL users");
                    res.json(success);
                }
            });
    }

    // make a copy of the original users Array because we're going to mutate it
    getOneUser(Array.from(users)); 
}

上面所做的是为一个用户发出一个请求，然后当响应到达时触发另一个请求

我希望这能有所帮助。
@phantom是否引发任何异常？（抱歉，我意外删除了您的评论）我已将代码更改为使用会话。数组现在是
req.session.users
。这意味着最后的代码看起来像
getOneUser（array.from（req.session.users））
递归函数中的代码是否仍被称为
users
，因为这是传入的参数，还是我需要将其更改为
req.session.users
。也就是说，它应该是
if（users.length）.
还是
if（req.session.users.length）…
在我的代码中，递归函数的
users
参数隐藏了外部参数（我应该重命名它）。您可以将其命名为
users
。