Question

I m 采用斜线,需要方法。

然而,正如预期的那样,我需要以一系列方式开展这项工作,而不是像现在那样做。

是否有办法在一系列轮 to/回击方法中使用这种说法?

Answer 1

Given something like this:

function f() {
    some_async_call({ callback: function(err, results) {...})
}
_(3).times(f);

然后,三个<代码>f 电话将按系列进行,但<代码>sint_async_ calls 电话必定是连续发生的,因为它们是同步的。

如果你要迫使你发出一系列呼吁,那么你就应该利用“yn”呼吁,在系列中发出下一个呼吁:

function f(times, step) {
    step = step || 0;
    some_async_call({
        callback: function(err, results) {
            // Do something with `err` and `results`...
            if(step < times)
                f(times, step + 1);
        }
    });
}
f(3);

That approach will execute the three some_async_calls in series but, alas, the initial f(3) will return immediately. One solution to that problem is, of course, another callback:

function f(from_n, upto, and_finally) {
    some_async_call({
        callback: function(err, results) {
            // Do something with `err` and `results`...
            if(from_n < upto)
                f(from_n + 1, upto, and_finally);
            else
                and_finally();
        }
    });
}
f(0, 3, function() { console.log( all done ) });

<代码>在哪里? : is only a ∗∗∗∗



_.times = function(n, iterator, context) {
  for (var i = 0; i < n; i++) iterator.call(context, i);
};


。 如果你真心想要的话,你也许会错失,但你会做一个大的 me子,而不是简化你的法典。

您可以使用250R s async想法,但您必须建立一系列三个功能,但和。 这比<代码>更合适。


// Untested off the top of my head code...

function f(callback) {
    some_async_call({
        callback: function(err, results) {
            // Deal with `err` and `results`...
            callback();
        }
    });
}

var three_fs = _(3).range().map(function() { return f });
async.series(three_fs);


但您仍需修改<条码>f,以备有退约功能,如果您总是重打<条码>f。 其后三次:

async.series([f, f, f]);


可能比用<代码>——和——>积极构建阵列更好。


这里的真正教训是,一旦你履行不尽人意的职能,你就会最终执行你的所有逻辑,作为呼吁退步的退步, all倒一切。

Answer 2

This async library might get you started https://github.com/caolan/async#series

或者,如果你想这样做,想法是在每个功能反馈之后,在源代码。

友情链接