I have an array which is returned from an API in the format of [a, b, c, d, e, f ... ], where a,c,e and b,d,f are of the same type, respectively. Now I want to group the array into [ [a,b], [c,d], [e,f] ...]. It's fairly easy by creating a new array, but the array is large so that could be slow.
So I'm wondering if there're any methods that can do it in-place?
Do you want it in 2 section chunks?
var o = ['a', 'b', 'c', 'd', 'e', 'f'],
size = 2, i, ar = []; // The new array
for (i = 0; i < o.length; i += size) ar.push(o.slice(i,i + size));
Now, ar is:
[
['a', 'b'],
['c', 'd'],
['e', 'f']
]
No matter how you do it, there is alway going to be some looping. The compiler has to go through all the array elements to make the new array.
So I'll create an array with this:
var l = 10000000, // The length
o = [], j;
for (j = 0; j < l; j += 1) o.push(j);
So that will make an array with l items now to test the speed:
var start = performance.now(),
size = 2, ar = [];
for (i = 0; i < o.length; i += size) ar.push(o.slice(i,i + size));
console.log(performance.now() - start);
100 Thousand: 0.092909533996135 seconds
1 Million: 0.359059600101318 seconds
10 Million: 10.138852232019417 seconds
The 10 million time might surprise but if you have that big of an array you have bigger problems such as memory issues. And if this array is coming from a server you are probably going to be putting excessive strain on the server.
This is wanton use of a library even though op is concerned about performance, but I like using lodash/underscore for easily-comprehensible code:
_.partition('a,b,c,d,e,f'.split(','), function(_, idx) {return !(idx % 2);})
An in place solution is to just iterate as normal, building arrays and 'skipping' elements by splicing them before you reach them.
var arr = ['a', 'b', 'c', 'd', 'e', 'f'];
function compact (arr) {
for(var i = 0; i < arr.length; i++) {
arr[i] = [arr[i], arr[i + 1]];
arr.splice(i + 1, 1);
}
return arr; // debug only
}
console.log(compact(arr.slice()));
// >> [["a", "b"], ["c", "d"], ["e", "f"]]Untested as far as performance goes. I would agree with the comments that it's most likely slower to manipulate the array in place, as apposed to building a new array.
