我已将您的代码示例缩减为以下几行，以便更容易理解该概念的解释。

var results = [];
var config = JSON.parse(queries);
for (var key in config) {
    var query = config[key].query;
    search(query, function(result) {
        results.push(result);
    });
}
res.writeHead( ... );
res.end(results);

前面代码的问题是search函数是异步的，所以当循环结束时，没有调用任何回调函数。因此，列表results为空。

要解决此问题，您必须将代码放在回调函数中的循环之后。

    search(query, function(result) {
        results.push(result);
        // Put res.writeHead( ... ) and res.end(results) here
    });

但是，由于回调函数被多次调用（每次迭代一次），您需要以某种方式知道所有回调都已被调用。为此，您需要计算回调的数量，并检查该数量是否等于异步函数调用的数量。

要获取所有键的列表，请使用Object.keys. 然后，为了遍历这个列表，我使用.forEach（您也可以使用for (var i = 0, key = keys[i]; i < keys.length; ++i) { .. }，但这可能会产生问题，请参阅循环内的 JavaScript 闭包 - 简单的实际示例）。

这是一个完整的例子：

var results = [];
var config = JSON.parse(queries);
var onComplete = function() {
    res.writeHead( ... );
    res.end(results);
};
var keys = Object.keys(config);
var tasksToGo = keys.length;
if (tasksToGo === 0) {
   onComplete();
} else {
    // There is at least one element, so the callback will be called.
    keys.forEach(function(key) {
        var query = config[key].query;
        search(query, function(result) {
            results.push(result);
            if (--tasksToGo === 0) {
                // No tasks left, good to go
                onComplete();
            }
        });
    });
}

注意：上例中的异步代码是并行执行的。如果函数需要按照特定的顺序调用，那么可以使用递归来达到想要的效果：

var results = [];
var config = JSON.parse(queries);
var keys = Object.keys(config);
(function next(index) {
    if (index === keys.length) { // No items left
        res.writeHead( ... );
        res.end(results);
        return;
    }
    var key = keys[index];
    var query = config[key].query;
    search(query, function(result) {
        results.push(result);
        next(index + 1);
    });
})(0);

我展示的是概念，您可以在您的实现中使用许多（第三方）NodeJS module之一，例如async。

你已经正确地诊断出你的问题，干得好。一旦您调用搜索代码，for 循环就会继续运行。

我是https://github.com/caolan/async 的忠实粉丝，它对我很有用。基本上有了它，你最终会得到类似的东西：

var async = require('async')
async.eachSeries(Object.keys(config), function (key, next){ 
  search(config[key].query, function(err, result) { // <----- I added an err here
    if (err) return next(err)  // <---- don't keep going if there was an error

    var json = JSON.stringify({
      "result": result
    });
    results[key] = {
      "result": result
    }
    next()    /* <---- critical piece.  This is how the forEach knows to continue to
                       the next loop.  Must be called inside search's callback so that
                       it doesn't loop prematurely.*/
  })
}, function(err) {
  console.log('iterating done');
}); 

我希望这有帮助！

Node.js介绍了async await在7.6所以这使得Javascript更美丽。

var results = [];
var config = JSON.parse(queries);
for (var key in config) {
  var query = config[key].query;
  results.push(await search(query));
}
res.writeHead( ... );
res.end(results);

为此，search功能必须返回 apromise或必须是async函数

如果它没有返回一个Promise你可以帮助它返回一个Promise

function asyncSearch(query) {
  return new Promise((resolve, reject) => {
   search(query,(result)=>{
    resolve(result);
   })
  })
}

然后将这一行替换await search(query);为await asyncSearch(query);

我喜欢在这种情况下使用递归模式。例如，这样的事情：

// If config is an array of queries
var config = JSON.parse(queries.queryArray);   

// Array of results
var results;

processQueries(config);

function processQueries(queries) {
    var searchQuery;

    if (queries.length == 0) {
        // All queries complete
        res.writeHead(200, {'content-type': 'application/json'});
        res.end(JSON.stringify({results: results}));
        return;
    }

    searchQuery = queries.pop();

    search(searchQuery, function(result) {
        results.push(JSON.stringify({result: result}); 
        processQueries();            
    });
}

processQueries是一个递归函数，它将从要处理的查询数组中提取一个查询元素。然后processQueries当查询完成时回调函数再次调用。processQueries当没有查询时，知道结束。

使用数组最容易做到这一点，但可以修改它以使用我想象的对象键/值。