Fastest way to Reduce and concat (or deep flatten) arrays of arrays

Question

As input, I receive two types of arrays of arrays made of x and y coordinates that represent polygon and multipolygon geometries.

array1 represents coordinates of a simple polygon geometry and array2 represent a multipolygon geometry:

var array1 = [[[0 , 0], [0, 1], [0 ,2]]]

var array2 = [[[[0, 0] , [0, 1], [0, 2]], [[1, 0], [1, 1], [1 ,2]]]]

Multipolygon geometry (array2) are represented by an array of arrays one level deeper than simple polygon geometry (array1).

I want to flatten those arrays in order to get those output:

   if input is array1 type : array1_out = [[0, 0, 0, 1, 0, 2]]

   if input is array2 type : array2_out = [[0, 0, 0, 1, 0, 2], [1, 0, 1, 1, 1, 2]]

My function is the following:

for (i=0; i < array_input.length; i++){
    var array_concat = array_input[i].reduce(function(a, b){
        return a.concat(b);
    });
}

With this function above, the output for array1 is correct but the output of array2 is the following:

[[[0, 0] ,[0, 1], [0, 2]], [1, 0], [1, 1], [1, 2]]]

Is there a function to deeply flatten those two types of arrays?

Edit: Performance really matter here as the arrays are really big

Care to describe your logic for this operation in explicit English terms? — deceze, Aug 28 '15 at 13:23
possible duplicate of [Merge/flatten an Array of Arrays in JavaScript?](http://stackoverflow.com/questions/10865025/merge-flatten-an-array-of-arrays-in-javascript) — Andreas, Aug 28 '15 at 13:23
What exactly do you want to do to those arrays to get from your input to your desired output? Described in words. — deceze, Aug 28 '15 at 13:24
There are many ways you can go about this, I suggest using Lodash https://lodash.com/docs#flatten — , Aug 28 '15 at 13:38
@Grundy I am looking for a single function that will handle those two types of arrays that could be found in input — Below the Radar, Aug 28 '15 at 13:44

score 1 · Answer 1 · answered Aug 28 '15 at 14:03

You can add a small wrapper for your function, that can check what type in input and a bit modify input

function getDeepLength(arr) {
  for (var i = 0, cur = arr; cur[0] instanceof Array; i++, cur = cur[0]);
  return i;
}

function Flatten(array_input) {
  var array_concat = [];
  for (i = 0; i < array_input.length; i++) {
    array_concat.push(array_input[i].reduce(function(a, b) {
      return a.concat(b);
    }));
  }
  return array_concat;
}

function Wrapper(arr) {
  var deep = getDeepLength(arr);
  var cur = arr;
  if (deep > 2) {
    for (var i = deep - 2; i > 0; i--, cur = cur[0]);
  }
  return Flatten(cur)
}

var array1 = [
  [
    [0, 0],
    [0, 1],
    [0, 2]
  ]
];

var array2 = [
  [
    [
      [0, 0],
      [0, 1],
      [0, 2]
    ],
    [
      [1, 0],
      [1, 1],
      [1, 2]
    ]
  ]
];

document.getElementById('r').innerHTML = "array1: " 
+ JSON.stringify(array1)+"<br/>"
+ "flat array1: "+JSON.stringify(Wrapper(array1))+"<br/>"
+ "array2: "+JSON.stringify(array2)+"<br/>"
+ "flat array2: "+JSON.stringify(Wrapper(array2));

<div id='r'></div>

score 1 · Accepted Answer · answered Aug 28 '15 at 14:10

You can find a lot of helpful tools for manipulating arrays and collections in the Underscore and lodash libraries.

var arrays1 = [[[0 , 0], [0, 1], [0 ,2]]];
var array2 = [[[[0, 0] , [0, 1], [0, 2]], [[1, 0], [1, 1], [1 ,2]], ]];

var array1_out = flattenSimple(arrays1);
console.log(JSON.stringify(array1_out));

var array2_out = flattenMultiple(array2);
console.log(JSON.stringify(array2_out));

function flattenSimple(array_input) {    
    return _.flatten(array_input);
}

function flattenMultiple(array_input) {
    array_input = array_input[0];
    return array_input.map(function(a) {
        return _.flatten(a);
    });
}

Will produce the output you're looking for. I broke it into a flatten fn for each type, but you could use the same fn with a flag or more complex logic to know which type you're working with.

Fiddle

Fastest way to Reduce and concat (or deep flatten) arrays of arrays

2 Answers2