嵌套列表的 Javascript 长度

Question

目标:给定一个混合类型的数组，确定每个级别的元素数量。如果同一层有两个子数组，则它们的每个元素都计入该层元素的总数。

方法:

Array.prototype.elementsAtLevels = function( level, levelData ) {
  if ( level == undefined ) { level = 0;  } else { level += 1 }
  if ( levelData == undefined ) { levelData = {}; }
  if ( levelData[level] == undefined ) { levelData[level] = this.length} else { levelData[level] += this.length }
  this.map(function(e, i) {if (Array.isArray(e)){ e.elementsAtLevels(level, levelData) }})
  return levelData
}

测试用例:

[
  1,      // 0: 1
  1,      // 0: 2
  1,      // 0: 3
  1,      // 0: 4
  [       // 0: 5
    2,    // 1: 1
    2,    // 1: 2
    2     // 1: 3
  ], 
  [       // 0: 6
    [     // 1: 4
      3,  // 2: 1
      3   // 2: 2
    ],   
    [     // 1: 5
      [   // 2: 3
        4 // 3: 1
      ]
    ]
  ]
].elementsAtLevels()

// Object [ 6, 5, 3, 1 ]

问题: 有没有更有效的方法来计算这个？

Answer 1

我写了一些与您所拥有的非常相似的东西，并且在非常基本的基准测试中，它的运行时间不到一半。

let a = [1,1,1,1,[2,2,2],[[3,3],[[4]]]];

Array.prototype.elementsAtLevels2 = function (level, lData) {
    if (!level || !lData) {
        level = 0;
        lData = {};
    }

    if (!(level in lData)) {
        lData[level] = this.length;
    } else {
        lData[level] += this.length;
    }
    this.forEach(function (v) {
        if (Array.isArray(v))
            v.elementsAtLevels2(level + 1, lData);
    });

    return lData;
}

console.log(a.elementsAtLevels2());

我猜测主要的性能提升可能来自 forEach vs map，map 创建一个新数组，其中 forEach 没有。

编辑

它在 JSBin 中