如何同步请求？

Question

我使用nodejs + express + mongoose。假设我有两个模式和模型：“水果”和“蔬菜”。

假设我有以下几点：

var testlist = ["Tomato", "Carrot", "Orange"]; 
var convertedList = []; 
// Assume res is the "response" object in express 

我婉能够在阵列中检查每个项目对“水果”和“蔬菜”集合分别将它们插入到一个转换的列表，其中番茄，胡萝卜和西兰花被他们各自的文件替换。

下面我有一些我认为会是的伪代码，但不知道该怎么做。

for(var i = 0; i < testlist.length; i++) { 
var fruitfind = Fruit.find({"name":testlist[i]}); 
var vegfind = Vegetables.find({"name":testlist[i]}); 

// If fruit only 
if(fruitfind) { 
convertedList.push(fruitfindresults); 
} 
// If vegetable only 
else if(vegfind) { 

convertedList.push(vegfindresults); 
} 
// If identified as a fruit and a vegetable (assume tomato is a doc listed under both fruit and vegetable collections) 
else if (fruitfind && vegfind) { 
convertedList.push(vegfindresults); 
} 
} 

// Converted List should now contain the appropriate docs found. 
res.send(convertedList) // Always appears to return empty array... how to deal with waiting for all the callbacks to finish for the fruitfind and vegfinds? 

这样做的最好方法是什么？或者这甚至有可能？

Answer 1

假设每个水果/蔬菜中只有一个，并且您打算推送两次收集到的蔬菜。

var async = require("async"), 
    testlist = ["Tomato", "Carrot", "Orange"]; 

async.map(testlist, function (plant, next) { 
    async.parallel([function (done) { 
    Fruit.findOne({"name": plant}, done); 
    }, 
    function (done) { 
    Vegetables.findOne({"name": plant}, done); 
    }], function (err, plants) { // Edited: before it was (err, fruit, veggie) which is wrong 
    next(err, plants); 
    }); 
}, 
function (err, result) { 
    var convertedList = [].concat(result); 
    res.send(convertedList); 
}); 

注意：还没有真正测试代码，但它应该工作。 The async module非常适合用来管理像这样的顺便回调。

更新

要获得每个水果只有一次，async.parallel回调只需要重写这样的：

function (err, plants) { 
    next(err, plants[0] || plants[1]); 
} 

而且也没有在.MAP回调不再需要CONCAT：

function (err, result) { 
    res.send(result); 
} 

Answer 2

find是一个异步函数，它使所述蒙戈数据库的请求。这意味着两件事：

1. 函数不会立即返回结果。猫鼬中的find函数遵循非常常见的异步模式。它接受一个“回调”函数，它将调用结果或错误。通过节点约定，如果第一个参数不为空，那就是错误。

   // So typically you'd call find like this 
   SomeModel.find({your: 'conditions'}, function (err, results) { 
       if (err) { 
       // some error has occurred which you must handle 
       } else { 
       res.send(results); 
       } 
   }) 
   // note that if code existed on the lines following the find, it would 
   // be executed *before* the find completed. 
   

2. 由于每个查询发射另一个请求关闭数据库，您通常希望如果可以的数目进行限制。在这种情况下，您可以通过使用mongo的$in来一次查找所有名字，而不是通过名称查找每个水果/蔬菜。

考虑到这两个东西，你的代码可能是这个样子：

// here *first* we're finding fruits 
Fruit.find({name: {$in: testlist}}, function (err, fruits) { 

    // when the fruit request calls back with results, we find vegetables 
    Vegetable.find({name: {$in: testlist}}, function (err, vegetables) { 

    // finally concat and send the results 
    res.send(fruits.concat(vegetables)); 
    }); 
}); 

兼得请求并行发生，更多的工作是必需的。你可以使用库像async，或者写自己的东西，如：

var fruits 
    , vegetables 
    , done = function() { 
     if (fruits && vegetables) { 
     res.send(fruits.concat(vegetables)); 
     } 
    } 

Fruit.find({name: {$in: testlist}}, function (err, docs) { 
    fruits = docs; 
    done(); 
}); 

Vegetable.find({name: {$in: testlist}}, function (err, docs) { 
    vegetables = docs; 
    done(); 
}); 

注意的是，这里两个例子，只是CONCAT结果，并给他们，因为你想怎么处理结果尚不清楚。这意味着，例如，如果一份西红柿都在这两份名单中，它会在结果中出现两次，包括蔬菜和水果文件。

您还需要处理从猫鼬回来的任何错误。

编辑：唯一命名的文档

在您的评论的光，这是一种方式，你可能只返回一个文档番茄（或其他记录是既水果和蔬菜）

// after retrieving fruits and vegetables, create a map which will 
// serve to weed out docs with duplicate names 
var map = {}; 

fruits.forEach(function (fruit) { 
    map[fruit.name] = fruit; 
}); 

vegetables.forEach(function (vegetable) { 
    map[vegetable.name] = vegetable; 
}); 

var results = []; 

// this would sort by name 
Object.keys(map).sort().forEach(function (key, i) { 
    results[i] = map[key]; 
}); 

res.send(results); 

请注意，如果您需要对两个查询的结果进行排序和分页或以其他方式限制这两个查询的结果，则此类事情会变得复杂得多，并且如果您需要这样做，则可以考虑将文档保留在同一个集合中。