# Split array into chunks

## Split array into chunks

Let’s say that I have an Javascript array looking as following:
[“Element 1″,”Element 2″,”Element 3”,…]; // with close to a hundred elements.

What approach would be appropriate to chunk (split) the array into many smaller arrays with, lets say, 10 elements at its most?

### Solution 1:

The array.slice method can extract a slice from the beginning, middle, or end of an array for whatever purposes you require, without changing the original array.

``````var i,j,temparray,chunk = 10;
for (i=0,j=array.length; i<j; i+=chunk) {
temparray = array.slice(i,i+chunk);
// do whatever
}
``````

### Solution 2:

Modified from an answer by dbaseman: https://stackoverflow.com/a/10456344/711085

``````Object.defineProperty(Array.prototype, 'chunk_inefficient', {
value: function(chunkSize) {
var array = this;
return [].concat.apply([],
array.map(function(elem, i) {
return i % chunkSize ? [] : [array.slice(i, i + chunkSize)];
})
);
}
});

console.log(
[1, 2, 3, 4, 5, 6, 7].chunk_inefficient(3)
)
// [[1, 2, 3], [4, 5, 6], ]``````

I should point out that the above is a not-that-elegant (in my mind) workaround to use `Array.map`. It basically does the following, where ~ is concatenation:

``````[[1,2,3]]~[]~[]~[] ~ [[4,5,6]]~[]~[]~[] ~ []
``````

It has the same asymptotic running time as the method below, but perhaps a worse constant factor due to building empty lists. One could rewrite this as follows (mostly the same as Blazemonger’s method, which is why I did not originally submit this answer):

More efficient method:

``````// refresh page if experimenting and you already defined Array.prototype.chunk

Object.defineProperty(Array.prototype, 'chunk', {
value: function(chunkSize) {
var R = [];
for (var i = 0; i < this.length; i += chunkSize)
R.push(this.slice(i, i + chunkSize));
return R;
}
});

console.log(
[1, 2, 3, 4, 5, 6, 7].chunk(3)
)``````

My preferred way nowadays is the above, or one of the following:

``````Array.range = function(n) {
// Array.range(5) --> [0,1,2,3,4]
return Array.apply(null,Array(n)).map((x,i) => i)
};

Object.defineProperty(Array.prototype, 'chunk', {
value: function(n) {

// ACTUAL CODE FOR CHUNKING ARRAY:
return Array.range(Math.ceil(this.length/n)).map((x,i) => this.slice(i*n,i*n+n));

}
});
``````

Demo:

``````> JSON.stringify( Array.range(10).chunk(3) );
[[1,2,3],[4,5,6],[7,8,9],]
``````

Or if you don’t want an Array.range function, it’s actually just a one-liner (excluding the fluff):

``````var ceil = Math.ceil;

Object.defineProperty(Array.prototype, 'chunk', {value: function(n) {
return Array(ceil(this.length/n)).fill().map((_,i) => this.slice(i*n,i*n+n));
}});
``````

or

``````Object.defineProperty(Array.prototype, 'chunk', {value: function(n) {
return Array.from(Array(ceil(this.length/n)), (_,i)=>this.slice(i*n,i*n+n));
}});
``````

### Solution 3:

Try to avoid mucking with native prototypes, including Array.prototype, if you don’t know who will be consuming your code (3rd parties, coworkers, yourself at a later date, etc.).

There are ways to safely extend prototypes (but not in all browsers) and there are ways to safely consume objects created from extended prototypes, but a better rule of thumb is to follow the Principle of Least Surprise and avoid these practices altogether.

If you have some time, watch Andrew Dupont’s JSConf 2011 talk, “Everything is Permitted: Extending Built-ins”, for a good discussion about this topic.

But back to the question, while the solutions above will work, they are overly complex and requiring unnecessary computational overhead. Here is my solution:

``````function chunk (arr, len) {

var chunks = [],
i = 0,
n = arr.length;

while (i < n) {
chunks.push(arr.slice(i, i += len));
}

return chunks;
}

// Optionally, you can do the following to avoid cluttering the global namespace:
Array.chunk = chunk;
``````

### Solution 4:

Here’s a ES6 version using reduce

``````perChunk = 2 // items per chunk

inputArray = ['a','b','c','d','e']

inputArray.reduce((resultArray, item, index) => {
const chunkIndex = Math.floor(index/perChunk)

if(!resultArray[chunkIndex]) {
resultArray[chunkIndex] = [] // start a new chunk
}

resultArray[chunkIndex].push(item)

return resultArray
}, [])

// result: [['a','b'], ['c','d'], ['e']]
``````

And you’re ready to chain further map/reduce transformations.
Your input array is left intact

If you prefer a shorter but less readable version, you can sprinkle some `concat` into the mix for the same end result:

``````inputArray.reduce((all,one,i) => {
const ch = Math.floor(i/perChunk);
all[ch] = [].concat((all[ch]||[]),one);
return all
}, [])
``````

### Solution 5:

I tested the different answers into jsperf.com. The result is available there: http://jsperf.com/chunk-mtds

And the fastest functio (and that works from IE8) is this one:

``````function chunk(arr, chunkSize) {
var R = [];
for (var i=0,len=arr.length; i<len; i+=chunkSize)
R.push(arr.slice(i,i+chunkSize));
return R;
}
``````

### Solution 6:

I’d prefer to use splice method:

``````var chunks = function(array, size) {
var results = [];
while (array.length) {
results.push(array.splice(0, size));
}
return results;
};
``````