Question

我的目标是按顺序执行一些javascript函数，其中一个函数的结果经常（但不总是）用作另一个函数的参数。

var async = require('async');

var commonFunction1 = function(arg1, arg2, callback) { // callback(err, res1, res2)
  callback(null, arg1 + arg2, 11);
}

var commonFunction2 = function(arg3, arg4, callback) { // callbackb(err, res3, res4)
  callback(null, arg3 + arg4, 90);
}

var argument1 = 1,
    argument2 = 2,
    result1,
    result2,
    result3,
    result4;

async.series({
  1: function(cb) {
    commonFunction1(argument1, argument2, function(err, res1, res2) {
      result1 = res1;
      result2 = res2;
      cb(err);
    });
  },
  2: function(cb) {
    commonFunction2(result1, result2, function(err, res3, res4) {
      result3 = res3;
      result4 = res4;
      cb(err);
    });
  },
}, function(err, results) {
  console.log(err, result1, result2, result3, result4);
});

如您所见，result1 = res1之类的语句是强制语法糖。

有没有更好的方法来链接局部变量和回调函数参数？

P.S。闭包不是我的方式，因为我打算将commonFunction1和commonFunction2移到另一个模块。

Answer 1

使用预期使用的系列，只将一个结果传递给下一个回调：

async.series([function(next) {
        commonFunction1(argument1, argument2, function(err, res1, res2) {
          next(err,{result1:res1,result2:res2});
        });
      ,
      function(next) {
        commonFunction2(result1, result2, function(err, res3, res4) {
          next(err,{result3:res3,result4:res4});
        });
      }],function(err,results){
             var finalObject= results.reduce(function(res,next){
                 Object.keys(next).forEach(function(k){
                    res[k]=next[k];
                 });
                 return res;
             },{});
             console.log(finalObject);
      });

我建议你更好地构建你的commFunctions并返回一个带有属性的对象，而不是传递2个结果和错误。

var commonFunction1 = function(arg1, arg2, callback) { // callback(err, res1, res2)
  callback(err, {prop1:arg1 + arg2, prop2:11} );
}

这是nodejs中的最佳实践，只需查看异步核心函数，并使代码更易于使用。这样您就不必在最终的async.series回调中编写所有reduce代码，只需使用数组结果。

编辑：正如我的评论所述，async.waterfall对你的用例更好。

在回调函数中使用局部变量

1 个答案: