在 Javascript (V8) 中，为什么数组上的 forEach 比简单的 for 循环消耗更多的内存？

Question

我正在对 Node.js（版本 v7.5.0，包含 15849x12771 个条目的矩阵）中的大量数据执行一些简单的数据验证。出于性能原因，现在整个数据集都在内存中。因此，将消耗的内存量减少到理论上的最小值（每个数字在 JS 中代表 8 个字节）对我来说至关重要。

请比较以下实现相同目标的方法。

forEach

  regressData.forEach((yxa, yxaIndex) => {
    yxa.forEach((yx, yxIndex) => {
      if (!_.isFinite(yx)) {
        throw new Error(`non-finite entry at [${yxaIndex}, ${yxIndex}]`);
      }
    });
  });

这会消耗我所有节点进程的 4GB+ 内存，导致它永远不会（直到我的耐心耗尽）完成循环（我猜它会使用较慢的交换内存）。

然后是与典型for相同的版本：

  for (var yxai = 0, yxal = regressData.length; yxai < yxal; yxai++) {
    const yx = regressData[yxai];
    for (var yxi = 0, yxl = yx.length; yxi < yxl; yxi++) {
      if (!_.isFinite(yx[yxi])) {
        throw new Error(`non-finite entry at [${yxai}, ${yxi}]`);
      }
    }
  }

这几乎不会消耗额外的内存，从而在不到一秒的时间内完成验证。

这种行为是否符合预期？我曾预料到，由于 forEachs 具有封闭范围，因此与传统的 for 循环相比，不会出现额外内存使用的问题。

编辑：独立测试

节点 --expose-gc test_foreach.js

if (!gc) throw new Error('please run node like node --expose-gc test_foreach.js');

const _ = require('lodash');

// prepare data to work with

const x = 15849;
const y = 12771;

let regressData = new Array(x);
for (var i = 0; i < x; i++) {
  regressData[i] = new Array(y);
  for (var j = 0; j < y; j++) {
    regressData[i][j] = _.random(true);
  }
}

// for loop
gc();
const mb_pre_for = _.round(process.memoryUsage().heapUsed / 1024 / 1024, 2);
console.log(`memory consumption before for loop ${mb_pre_for} megabyte`);
validateFor(regressData);
gc();
const mb_post_for = _.round(process.memoryUsage().heapUsed / 1024 / 1024, 2);
const mb_for = _.round(mb_post_for - mb_pre_for, 2);
console.log(`memory consumption by for loop ${mb_for} megabyte`);

// for each loop
gc();
const mb_pre_foreach = _.round(process.memoryUsage().heapUsed / 1024 / 1024, 2);
console.log(`memory consumption before foreach loop ${mb_pre_foreach} megabyte`);
validateForEach(regressData);
gc();
const mb_post_foreach = _.round(process.memoryUsage().heapUsed / 1024 / 1024, 2);
const mb_foreach = _.round(mb_post_foreach - mb_pre_foreach, 2);
console.log(`memory consumption by foreach loop ${mb_foreach} megabyte`);

function validateFor(regressData) {
  for (var yxai = 0, yxal = regressData.length; yxai < yxal; yxai++) {
    const yx = regressData[yxai];
    for (var yxi = 0, yxl = yx.length; yxi < yxl; yxi++) {
      if (!_.isFinite(yx[yxi])) {
        throw new Error(`non-finite entry at [${yxai}, ${yxi}]`);
      }
    }
  }
};

function validateForEach(regressData) {
  regressData.forEach((yxa, yxaIndex) => {
    yxa.forEach((yx, yxIndex) => {
      if (!_.isFinite(yx)) {
        throw new Error(`non-finite entry at [${yxaIndex}, ${yxIndex}]`);
      }
    });
  });
};

输出：

toms-mbp-2:mem_test tommedema$ node --expose-gc test_foreach.js
memory consumption before for loop 1549.31 megabyte
memory consumption by for loop 0.31 megabyte
memory consumption before foreach loop 1549.66 megabyte
memory consumption by foreach loop 3087.9 megabyte

Answer 1

（这里是 V8 开发人员。）这是在 V8 的旧执行管道（完整代码生成 + 曲轴）中如何实现 Array.forEach 的不幸结果。简而言之，在某些情况下，在数组上使用 forEach 会将该数组的内部表示更改为内存效率低得多的格式。 （特别是：如果数组之前只包含双精度值，并且forEach 也被用于具有其他类型元素但没有太多不同类型对象的数组，并且代码运行得足够热以进行优化。这相当复杂； -))

使用新的执行管道（目前在--future 标志后面，很快就会默认打开），我不再看到这种额外的内存消耗。

（也就是说，经典的 for 循环确实比 forEach 具有较小的性能优势，只是因为底层发生的事情更少（根据 ES 规范）。在许多实际工作负载中，差异太小很重要，但在微基准测试中它通常是可见的。将来我们可能能够优化更多 forEach 的开销，但如果你知道每个 CPU 周期都很重要，我建议使用普通的旧 for (var i = 0; i < array.length; i++) 循环.)