JavaScript，Node.js：Array.forEach是否异步？

我对JavaScript的本机Array.forEach实现有疑问：它是否异步运行？ 例如，如果我打电话：

[many many elements].forEach(function () {lots of work to do})

这将是非阻塞的吗？

---

#1楼

这是一个简短的异步函数，无需第三方库即可使用

Array.prototype.each = function (iterator, callback) {
    var iterate = function () {
            pointer++;
            if (pointer >= this.length) {
                callback();
                return;
            }
            iterator.call(iterator, this[pointer], iterate, pointer);
    }.bind(this),
        pointer = -1;
    iterate(this);
};

---

#2楼

编辑2018-10-11：看起来下面描述的标准很有可能无法通过，可以考虑使用流水线作为替代方法（表现不完全相同，但是方法可以在类似的庄园中实现）。

这就是为什么我对es7感到兴奋的原因，将来您将能够执行类似以下代码的操作（某些规格不完整，因此请谨慎使用，我会尽量保持最新状态）。 但是基本上使用新的:: bind运算符，您将能够在对象上运行方法，就像对象的原型包含该方法一样。 例如[Object] :: [Method]，通常您会在其中调用[Object]。[ObjectsMethod]

请注意，今天（16年7月24日）执行此操作，并使它在所有浏览器中都有效，您将需要为以下功能转换代码： Import / Export ， Arrow函数 ， Promises ， Async / Await以及最重要的是bind函数 。 可以将下面的代码修改为仅在必要时使用函数绑定，而今天，通过使用babel可以轻松使用所有这些功能。

YourCode.js（“ 要做的很多工作 ”必须简单地返回一个承诺，在异步工作完成后就解决它。）

import { asyncForEach } from './ArrayExtensions.js';

await [many many elements]::asyncForEach(() => lots of work to do);

ArrayExtensions.js

export function asyncForEach(callback)
{
    return Promise.resolve(this).then(async (ar) =>
    {
        for(let i=0;i<ar.length;i++)
        {
            await callback.call(ar, ar[i], i, ar);
        }
    });
};

export function asyncMap(callback)
{
    return Promise.resolve(this).then(async (ar) =>
    {
        const out = [];
        for(let i=0;i<ar.length;i++)
        {
            out[i] = await callback.call(ar, ar[i], i, ar);
        }
        return out;
    });
};

---

#3楼

npm上有一个软件包， 用于每个循环的轻松异步 。

var forEachAsync = require('futures').forEachAsync;

// waits for one request to finish before beginning the next 
forEachAsync(['dogs', 'cats', 'octocats'], function (next, element, index, array) {
  getPics(element, next);
  // then after all of the elements have been handled 
  // the final callback fires to let you know it's all done 
  }).then(function () {
    console.log('All requests have finished');
});

也是AllAsync的另一个变体

---

#4楼

例如，甚至可以对这样的解决方案进行编码：

 var loop = function(i, data, callback) {
    if (i < data.length) {
        //TODO("SELECT * FROM stackoverflowUsers;", function(res) {
            //data[i].meta = res;
            console.log(i, data[i].title);
            return loop(i+1, data, errors, callback);
        //});
    } else {
       return callback(data);
    }
};

loop(0, [{"title": "hello"}, {"title": "world"}], function(data) {
    console.log("DONE\n"+data);
});

另一方面，它比“ for”要慢得多。

否则，出色的Async库可以做到这一点： https : //caolan.github.io/async/docs.html#each

---

#5楼

这是一个小示例，您可以运行对其进行测试：

[1,2,3,4,5,6,7,8,9].forEach(function(n){
    var sum = 0;
    console.log('Start for:' + n);
    for (var i = 0; i < ( 10 - n) * 100000000; i++)
        sum++;

    console.log('Ended for:' + n, sum);
});

它将产生类似这样的信息（如果花费的时间太少/太多，则增加/减少迭代次数）：

(index):48 Start for:1
(index):52 Ended for:1 900000000
(index):48 Start for:2
(index):52 Ended for:2 800000000
(index):48 Start for:3
(index):52 Ended for:3 700000000
(index):48 Start for:4
(index):52 Ended for:4 600000000
(index):48 Start for:5
(index):52 Ended for:5 500000000
(index):48 Start for:6
(index):52 Ended for:6 400000000
(index):48 Start for:7
(index):52 Ended for:7 300000000
(index):48 Start for:8
(index):52 Ended for:8 200000000
(index):48 Start for:9
(index):52 Ended for:9 100000000
(index):45 [Violation] 'load' handler took 7285ms

来源：oschina

链接：https://my.oschina.net/stackoom/blog/3170904