Is there a simpler way to sum the lengths of arrays within an array of arrays in JavaScript?

Question

I primarily work with C#, and when working with an array of arrays, I can sum the length of the sub arrays using Linq:

var myArray = new int[2][] {
    new int[3] { 1, 2, 3 },
    new int[4] { 1, 2, 3, 4 }
};
myArray.Sum(s => s.Length);

Printing the result of that sum to a console should produce a 7. With that in mind, I'm having trouble finding resources on a simple way to do this in JavaScript, and as such I'm stuck doing it with nested for iterators:

let containedLength = 0;
let myArray = [ [1, 2, 3], [1, 2, 3, 4] ];
for (let x = 0; x < myArray.length; x++)
    for (let y = 0; y < myArray[x].length; y++)
        containedLength++;

I could write a function to do this, but that would be over the top for what I'm trying to do today since I already have a basic way to do it. Is there a simpler way similar to C#'s Linq that could get the sum of the lengths of arrays, within an array of arrays?

Answer 1

There's no need for the inner loop to compute the length element by element. It's better to use the .length property on each row, reducing the inner loop time complexity to O(1), and covert your C-style loop to a for..of loop which is less prone to errors:

const arr = [[1, 2, 3], [1, 2, 3, 4]];
let innerLength = 0;

for (const row of arr) {
  innerLength += row.length;
}

console.log(innerLength);

(You can see a few style preferences here; use vertical whitespace and braces around for/if blocks, prefer const to let, avoid "my" in var name)

---

The above code isn't satisfying relative to the C# code, though. JS has a much less expressive API for array opterations than Linq. The normal approximation is to use map/reduce/flat/flatMap/filter-type functions. For example, if flat is available:

const arr = [[1, 2, 3], [1, 2, 3, 4]];
console.log(arr.flat().length); // flatten 1 level only, like original code

But the problem is that this is O(n) space, unlike your O(1) space code. We allocate and build a whole new array just to take its .length, then send it to the garbage collector.

Array#reduce can give you the functional style but preserving O(1) space and is probably the closest we can get to C# without helper functions or third-party libraries:

const arr = [[1, 2, 3], [1, 2, 3, 4]];
console.log(arr.reduce((a, e) => a + e.length, 0));

This is probably a little slower than for..of (due to function call overhead) and isn't quite as elegant as flat, but might be a good balance depending on your use case.

It's good not to prematurely optimize though, so flat() is fine for starters.

Answer 2

the simple way is to flatten out the array then get the length as it flattens out all the array.

let myArray = [ [1, 2, 3], [1, 2, 3, 4] ];
console.log(myArray.flat().length);

That will output 7.