node.js - 瀑布内的节点异步并行

Question

我正在 Nodejs 中构建一个服务器来从某个数据库中检索数据。我已经使用异步库有一段时间了，并想出了一些事情，比如将瀑布放在并行函数中。

我偶然发现了一个问题，我首先需要执行一个查询，然后在可以同时执行的其他查询中使用该查询的结果。代码看起来像这样：

async.waterfall([
    function(callback) {
        connection.query(   query,
                            function(err, rows, fields) {
                                if (!err) {
                                    callback(null,rows);
                                } else {
                                    callback(null,"SORRY");
                                }
                            }
        );
    },
    async.parallel([
        function(resultFromWaterfall,callback) {
            connection.query(query,
                            function(err, rows, fields) {
                                if (!err) {
                                    callback(null,rows);
                                } else {
                                    callback(null,"SORRY");
                                }
                            }
           );
        },
        function(resultFromWaterfall,callback) {
            connection.query(query,
                            function(err, rows, fields) {
                                if (!err) {
                                    callback(null,rows);
                                } else {
                                    callback(null,"SORRY");
                                }
                            }
           );
        }
    ])
], finalCallback
);

现在我的问题是访问瀑布函数的结果并在并行函数中使用它。

Answer 1

async.waterfall([
    function(callback) {
        connection.query(query,
            function(err, rows, fields) {
                if (!err) {
                    callback(null, rows);
                } else {
                    callback(null, "SORRY");
                }
            }
        );
    },
    function(prevData,callback){
      console.log(prevData);//Use it whereever you want.
      async.parallel([
          function(callbackOfAsyncParallel) {
              connection.query(query1,
                  function(err, rows1, fields1) {
                      if (!err) {
                          callbackOfAsyncParallel(null, rows1);
                      } else {
                          callbackOfAsyncParallel(null, "SORRY1");
                      }
                  }
              );
          },
          function(callback) {
              connection.query(query2,
                  function(err, rows2, fields2) {
                    if (!err) {
                        callbackOfAsyncParallel(null, rows2);
                    } else {
                        callbackOfAsyncParallel(null, "SORRY2");
                    }
                  }
              );
          }
      ],function mainCBOfParallel(err,reuslts){
        if(!err){
          //this will be done after tasks in async.parallel are finished.
          callback(null,results);
          //results[0]===>rows1
          //results[1]===>rows2
        }
      });
    }
], finalCallback);

您的代码中有两个错误，

1. 任务应该是一个要执行的函数。
2. async.parallel 在其任务函数中只有回调。

---

更新

callbackOfAsyncParallel当任务完成时，将调用回调 ( ) async.parallel。

它不应该调用回调（callback）。async.waterfall如果完成，可能会出现错误/意外结果。

Answer 2

试试这个..

    async.waterfall([

  function(callback) {
    connection.query(query,
      function(err, rows, fields) {
        if (!err) {
          callback(null, rows);
        } else {
          callback(null, "SORRY");
        }
      }
    );
  },
  function(resultFromWaterfall, callback) {
    async.parallel([

      function() {
        connection.query(query,
          function(err, rows, fields) {
            if (!err) {
              callback(null, rows);
            } else {
              callback(null, "SORRY");
            }
          }
        );
      },
      function() {
        connection.query(query,
          function(err, rows, fields) {
            if (!err) {
              callback(null, rows);
            } else {
              callback(null, "SORRY");
            }
          }
        );
      }
    ]);
  }

], finalCallback);

Answer 3

  doWhatever(callback) {
    async.waterfall([
      (waterfallCallback) => {
        connection.query(query, waterfallCallback);
      },
      (rows, fields, waterfallCallback) => {
        async.parallel([
          (parallelCallback) => {
            connection.query(query, parallelCallback);
          },
          (parallelCallback) => {
            connection.query(query, parallelCallback);
          }
        ], waterfallCallback);
      }
    ], callback);
  },

这只是我试图让它更清楚......</p>

无论如何，我的例子没有考虑查询的参数和参数。它只是一个脚手架