如何对多个查询使用异步并行

Question

我是 javascript 新手。

我曾尝试使用 async.parellel 函数。并获得“reviewArr”并返回它。

请看我的代码。

app.get('/api/wherecritique/reviews/search/:author', function(req,res){
   var reviewArr = [];
   Critique.find({author:req.params.autho}, function(err,cris){
       var i =0;
       var f = function(reviewID)
      {
          Review.findOne({id:reviewID}, function(err, review)
          {
               reviewArr.push(review);
          }
      }
      var tasks = {};
      for(var j =0; j<cris.length; j++)
      {
          tasks['func'+j] = f(cris[j].reviewID);
      }
      async.parallel(tasks, function(err, results){
          console.log(results);
          res.json(reviewArr);
      });
  });
});

我用猫鼬+express+node.js。批评、评论都是模型（猫鼬模式）。

当我运行此代码时，我收到此消息。“任务不是功能”

请帮助我如何解决此错误？问候。

Answer 1

您没有正确设置功能。预期的参数是function()带有参数的包装器，该callback参数在包含的异步函数完成时传递给。

你也真的只是想要async.map而不是你在做什么，因为它的输出是循环调用的结果数组。因此无需将结果推送到外部变量中：

app.get('/api/wherecritique/reviews/search/:author', function(req,res) {

  Critique.find({author: req.params.author}, function(err,cris) {

    async.map(
      cris.map( c => c.reviewID ),
      function(id, callback) {
        Review.findOne({ id: id }, callback);
      },
      function(err,results) {
        if (err) throw err; // or something with err
        console.log(results);
        res.json(results);
      }
    );

  });
});

但老实说，你真的应该在这里使用 Promises 而不是导入外部库

app.get('/api/wherecritique/reviews/search/:author', function(req,res) {

  Critique.find({author: req.params.author}, function(err,cris) {

    Promise.all(
      cris.map( c => Review.findOne({ id: c.reviewID }) )
    ).then( results => {
      console.log(results);
      res.json(results);
    }).catch( e => console.error(e) );

  });

});

或者以更现代的方式使用async/await：

app.get('/api/wherecritique/reviews/search/:author', async (req,res) => {

  try {       
    let cris = await Critique.find({author: req.params.author});

    let results = Promise.all(
      cris.map( c => Review.findOne({ id: c.reviewID }) )
    );
    console.log(results);
    res.json(results);
  } catch(e) {
    console.error(e);
  }

});

但实际上，这与 JavaScript 完全没有关系，您确实应该使用 MongoDB 功能。

无论是$lookup在支持的地方：

app.get('/api/wherecritique/reviews/search/:author', async (req,res) => {

  try {       
    let results = await Critique.aggregate([
      { $match: { author: req.params.author } },
      { $lookup: {
        from: Review.collection.name,
        localField: 'reviewID',
        foreignField: 'id'
        as: 'reviews'
      }},
      { $unwind: '$reviews' }
    ]);

    results = results.map( r => r.reviews );
    console.log(results);
    res.json(results);

  } catch(e) {
    console.error(e);
  }

});

或者，如果您没有，则只需将所有id值传递给$in：

app.get('/api/wherecritique/reviews/search/:author', async (req,res) => {

  try {       
    let cris = await Critique.find({ author: req.params.author });

    let results = await Review.find({ id: { $in: cris.map( c => c.reviewID ) } });
    console.log(results);
    res.json(results);

  } catch(e) {
    console.error(e);
  }

});

这意味着根据您的 MongoDB 版本对数据库的“一次”或“两次”实际调用。根本不需要循环异步调用。

最后，正如以上所解释的那样，确实没有必要，但正确的用法async.parallel是：

app.get('/api/wherecritique/reviews/search/:author', (req,res) => {

  Critique.find({author: req.params.author}, (err,cris) => {

    var tasks = cris.map( c => (callback) =>
        Review.findOne({ id: c.reviewID }, callback);
    );

    async.parallel(
      tasks,
      (err,results) => {
        if (err) throw err; // or something
        console.log(results);
        res.json(results);
      }
    )
  });
});