3  

Note: Array.prototype.forEach is synchronous, not asynchronous. Anything defined in the JS standard (ECMAScript 5th edition) cannot be asynchronous, because the standard does not define async semantics (Node.js and the DOM do).

注意:Array.prototype。forEach是同步的，而不是异步的。JS标准(ECMAScript第5版)中定义的任何内容都不能是异步的，因为标准没有定义异步语义(Node)。js和DOM do)。

You can use setTimeout (works in browsers and in Node.js) or process.nextTick (Node.js-specific):

您可以使用setTimeout(在浏览器和Node.js中工作)或进程。nextTick(Node.js-specific):

for (...) {
    doWorkAsync(...);
}

function doWorkAsync(...) {
    setTimeout(doWorkSync.bind(null, ...), 0);
}

function doWorkSync(...) {
    ...
}

Be careful when using free variables if you choose to exploit closures, as the variables may be mutated when your callback is finally called.

如果您选择使用闭包，那么在使用自由变量时要小心，因为当您的回调最终被调用时，变量可能会发生突变。

With an async framework, such as Q by kriskowal (portable across Node.js and modern browsers), you can do mapreduce-style programming:

使用异步框架，如kriskowal的Q(可跨节点移植)。)，你可以做mapreduce式的编程:

var Q = require('q');  // npm package 'q'

function getWorkloads() {
    var workloads = [ ];
    for (...) {
        workloads.push(Q.fcall(doWorkSync.bind(null, ...)));
    }
    return workloads;
}

Q.all(getWorkloads()).then(function (results) {
    // results array corresponds to
    // the array returned by getWorkloads.
});

0  

I am in the same boat. I kind of liked Node's async functions, so i wrote this async For and ForEach function. It uses the "setTimeout(Func,0);" trick.

我在同一条船上。我有点喜欢Node的异步函数，所以我为每个函数编写了这个async。它使用“setTimeout(Func,0)”技巧。

Here is the library:

这里是图书馆:

  var WilkesAsyncBurn = function()
  {
    var Now = function() {return (new Date());};
    var CreateFutureDate = function(milliseconds)
    {
      var t = Now();
      t.setTime(t.getTime() + milliseconds);
      return t;
    };
    var For = function(start, end, eachCallback, finalCallback, msBurnTime)
    {
      var i = start;
      var Each = function()
      {
        if(i==-1) {return;} //always does one last each with nothing to do
        setTimeout(Each,0);
        var burnTimeout = CreateFutureDate(msBurnTime);
        while(Now() < burnTimeout)
        {
          if(i>=end) {i=-1; finalCallback(); return;}
          eachCallback(i);
          i++;
        }
      };
      Each();
    };
    var ForEach = function(array, eachCallback, finalCallback, msBurnTime)
    {
      var i = 0;
      var len = array.length;
      var Each = function()
      {
        if(i==-1) {return;}
        setTimeout(Each,0);
        var burnTimeout = CreateFutureDate(msBurnTime);
        while(Now() < burnTimeout)
        {
          if(i>=len) {i=-1; finalCallback(array); return;}
          eachCallback(i, array[i]);
          i++;
        }
      };
      Each();
    };

    var pub = {};
    pub.For = For;          //eachCallback(index); finalCallback();
    pub.ForEach = ForEach;  //eachCallback(index,value); finalCallback(array);
    WilkesAsyncBurn = pub;
  };

Example Usage:

使用示例:

  WilkesAsyncBurn(); // Init the library
  console.log("start");
  var FuncEach = function(index)
  {
    if(index%10000==0)
    {
        console.log("index=" + index);
    }
  };
  var FuncFinal = function()
  {
    console.log("done"); 
  };
  WilkesAsyncBurn.For(0,2000000,FuncEach,FuncFinal,50);

prints: index=10000 index=20000 index=30000 etc "done"

打印:索引=10000索引=20000索引=30000等“完成”

More research if interested:

更多的研究如果感兴趣:

setTimeout and setInterval have a minimum overhead time of about 2 to 10 milliseconds, therefore, firing thousands or millions of timers is going to be slow for no reason. So basically, if you need to perform thousands or more loops without locking the browser, you need to be more like a thread (gasp), and "burn" some code for a set amount of time, rather than set amount of iterations.

setTimeout和setInterval的开销时间最小为2到10毫秒，因此，毫无理由地，触发数千或数百万个计时器将会很慢。因此，基本上，如果您需要在不锁定浏览器的情况下执行数千个或更多的循环，那么您需要更像一个线程(gasp)，并在一定的时间内“烧”一些代码，而不是设置迭代的数量。