如何处理依赖于多个其他异步函数的异步函数

Question

我有一个异步函数，它与其他两个异步函数的结果一起工作。

到目前为止，我所做的是在回调函数1中编写function2，在function2的回调中编写function2

function1(callbackFunction() {
    function2(callbackFunction() {
        function3()
    })
})

有没有其他方法可以解决这个问题。我通常在客户端和 nodeJs 中使用 JavaScript 代码。

我的情况是，对于函数 2，我不需要函数 1 的输出。换句话说，function1 和 function2 是独立的；但是function3依赖于function1和function2。

我希望我的函数 2 独立于函数 1 运行，但函数 3 运行同时依赖于函数 1 和函数 2。

有没有类似的

function1();
function2();
when(funtion1.complete && funtion2.complete) {
    function3();
}

Answer 1

有一些很好的库来处理编排异步函数。 async 和 q（或其他 Promises/A 库）帮助。

如果function2不依赖function1的结果，可以并行执行。以下是使用async 时的样子（这些示例假定您的回调具有function(err, result) 签名，这是Node 的实际模式：

async.parallel([
    function(callback) { function1(callback); },
    function(callback) { function2(callback); }
], function(err, values) {
    function3(values[0], values[1]);
});

如果function2 依赖于function1 的结果，waterfall 可能是更好的模式：

async.waterfall([
    function(callback) { function1(callback); },
    function(result, callback) { function2(result, callback); },
    function(result, callback) { function3(result, callback); },
]);

就个人而言，我喜欢q，因为你可以传递承诺并做各种漂亮的事情。这是使用它的外观：

q.nfcall(function1)
  .then(function(result) { return q.nfcall(function2); })
  .then(function(result) { return q.nfcall(function3); })
  .fail(function(err) {
      // If any of them fail, this is called.
  });

或者如果function1 和function2 可以按任意顺序完成：

q.all([q.nfcall(function1), q.nfcall(function2)])
 .then(function(values) { function3(values[0], values[1]); })
 .fail(function(err) {
 });

Answer 2

这是我烘焙的解决方案。您可以尝试调用管理器来调用依赖函数

var func1 = function() {
    console.log("Dependant call ... " + 1);
};
var func2 = function() {
    console.log("Dependant call ... " + 2);
};
var func3 = function() {
    console.log("Dependant call ... " + 3);
};
var func4 = function() {
    console.log("Dependant call ... " + 4);
};


var CallManager = function(funcs_config) {
    var _this = this;

    _this.functions = funcs_config;
    _this.callAsynchronous = function(f) {
        if (f != undefined) {
            for (var i = 0; i < f.length; i++) {
                f[i].call(function() {
                    this.callAsynchronous(f.splice(0,1));
                });
            }
            return;
        }

        for (var func in _this.functions) {
            if (_this.functions[func].length == 0) {
                //not dependent to any function
            } else {
                console.log('Calling....' + func);
                _this.callAsynchronous(_this.functions[func]);
                eval(func +'();');
            }
        }
    };

    return _this;
};


var callManager = new CallManager({
    //dependency configuration
    func2: [func1], //func2 depends on func1
    func3: [func2],
    func4: [func1, func3] //func4 depends on both func1 and func3
});

callManager.callAsynchronous();

使用上面提供的当前配置，运行时输出为 -

Calling....func2
Dependant call ... 1
Dependant call ... 2
Calling....func3
Dependant call ... 2
Dependant call ... 3
Calling....func4
Dependant call ... 1
Dependant call ... 3
Dependant call ... 4