Question

我有一个异步函数，可以处理另外两个异步函数的结果。

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

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

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

我的情况是，对于function2，我不需要从function1输出。换句话说，function1和function2是独立的;但是function3依赖于function1和function2。

我希望我的function2在function1上独立运行，但是function3依赖于functio1和function2来运行。

是否有类似

的内容

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

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

2 个答案: