JavaScript,Node.js:Array.forEach是异步的吗？

Question

我有一个关于Array.forEachJavaScript 的本机实现的问题:它是否异步？例如,如果我打电话:

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

这会不会阻塞吗？

Answer 1

不,它是封锁的.看看算法的规格.

但是,MDN可能更容易理解实现:

if (!Array.prototype.forEach)
{
  Array.prototype.forEach = function(fun /*, thisp */)
  {
    "use strict";

    if (this === void 0 || this === null)
      throw new TypeError();

    var t = Object(this);
    var len = t.length >>> 0;
    if (typeof fun !== "function")
      throw new TypeError();

    var thisp = arguments[1];
    for (var i = 0; i < len; i++)
    {
      if (i in t)
        fun.call(thisp, t[i], i, t);
    }
  };
}

如果必须为每个元素执行大量代码,则应考虑使用不同的方法:

function processArray(items, process) {
    var todo = items.concat();

    setTimeout(function() {
        process(todo.shift());
        if(todo.length > 0) {
            setTimeout(arguments.callee, 25);
        }
    }, 25);
}

然后用以下方法调用它:

processArray([many many elements], function () {lots of work to do});

那将是非阻塞的.该示例来自高性能JavaScript.

另一种选择可能是网络工作者.

Answer 2

如果你需要一个异步友好版本的Array.forEach和类似的,它们可以在Node.js的'async'模块中找到:http://github.com/caolan/async ...作为奖励,这个模块也有效在浏览器中.

async.each(openFiles, saveFile, function(err){
    // if any of the saves produced an error, err would equal that error
});

Answer 3

在Node中进行非常繁重的计算有一个共同的模式可能适用于你......

Node是单线程的(作为一个深思熟虑的设计选择,参见什么是Node.js？); 这意味着它只能使用单个核心.现代的盒子有8个,16个甚至更多的核心,因此可以使90%以上的机器闲置.REST服务的常见模式是为每个核心启动一个节点进程,并将它们放在像http://nginx.org/这样的本地负载均衡器之后.

分娩孩子 - 对于你想要做的事情,还有另一种常见的模式,就是要求儿童过程完成繁重的工作.好处是子进程可以在后台执行大量计算,而父进程可以响应其他事件.问题是你不能/不应该与这个子进程共享内存(不是没有很多扭曲和一些本机代码); 你必须传递消息.如果输入和输出数据的大小与必须执行的计算相比较小,则可以很好地工作.您甚至可以启动子node.js进程并使用您之前使用的相同代码.

例如:

var child_process = require('child_process');
function run_in_child(array, cb) {
    var process = child_process.exec('node libfn.js', function(err, stdout, stderr) {
        var output = JSON.parse(stdout);
        cb(err, output);
    });
    process.stdin.write(JSON.stringify(array), 'utf8');
    process.stdin.end();
}

Answer 4

Array.forEach意味着不需要等待就可以进行计算，并且在事件循环中使计算异步化是没有任何收获的（如果需要多核计算，网络工作人员可以添加多处理功能）。如果要等待多个任务结束，请使用计数器，您可以将其包装在信号量类中。

Answer 5

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

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

请注意今天（16 年 7 月 24 日）执行此操作并使其在所有浏览器中运行，您需要为以下功能转换代码：导入/导出、箭头函数、承诺、异步/等待和最重要的函数绑定。如果需要，可以修改下面的代码以仅使用函数绑定，所有这些功能今天都可以使用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;
    });
};