Odtnhj

I just made an iterative implementation of the algorithm: http://jsfiddle.net/ht22q/. It passes your test cases.

function splitUp(arr, n) 
 var rest = arr.length % n, // how much to divide
 restUsed = rest, // to keep track of the division over the elements
 partLength = Math.floor(arr.length / n),
 result = ;

 for(var i = 0; i < arr.length; i += partLength) 
 var end = partLength + i,
 add = false;

 if(rest !== 0 && restUsed) // should add one element for the division
 end++;
 restUsed--; // we've used one division element now
 add = true;
 

 result.push(arr.slice(i, end)); // part of the array

 if(add) 
 i++; // also increment i in the case we added an extra element for division
 
 

 return result;

I think this way using splice is the cleanest:

splitToChunks(array, parts) 
 let result = ;
 for (let i = parts; i > 0; i--) 
 result.push(array.splice(0, Math.ceil(array.length / i)));
 
 return result;

For example, for parts = 3, you would take 1/3, then 1/2 of the remaining part, then the rest of the array. Math.ceil ensures that in case of uneven number of elements they will go to the earliest chunks.

(Note: this destroys the initial array.)

You can reduce it into a matrix. The example below split the array (arr) into a matrix of two-positions arrays. If you want other sizes just change the 2 value on the second line:

target.reduce((memo, value, index) => 
 if (index % 2 == 0 && index !== 0) memo.push()
 memo[memo.length - 1].push(value)
 return memo
, [])

Hope it helps!

EDIT: Because some people is still commenting this doesn't answer the question since I was fixing the size of each chunk instead of the number of chunks I want. Here it comes the code explaining what I'm trying to explain in the comments section: Using the target.length.

// Chunk function

const chunk = (target, size) => 
 return target.reduce((memo, value, index) => 
 // Here it comes the only difference
 if (index % (target.length / size) == 0 && index !== 0) memo.push()
 memo[memo.length - 1].push(value)
 return memo
 , [])


// Usage

write(chunk([1, 2, 3, 4], 2))
write(chunk([1, 2, 3, 4], 4))

// For rendering pruposes. Ignore
function write (content) document.write(JSON.stringify(content), '</br>') 

Old question, but since vanillaJS is not a requirement and so many are trying to solve this with lodash/chunk, and without mistaking what _.chunk actually does, here's a concise + accurate solution using lodash:

(Unlike the accepted answer, this also guarantees n columns even if originalArray.length < numCols)

import _chunk from 'lodash/chunk'

/**
 * Split an array into n subarrays (or columns)
 * @param Array flatArray Doesn't necessarily have to be flat, but this func only works 1 level deep
 * @param Number numCols The desired number of columns
 * @return Array
 */
export function splitArray(flatArray, numCols)
 const maxColLength = Math.ceil(flatArray.length/numCols)
 const nestedArray = _chunk(flatArray, maxColLength)
 let newArray = 
 for (var i = 0; i < numCols; i++) 
 newArray[i] = nestedArray[i] 
 return newArray

The for loop at the end is what guarantees the desired number of "columns".

Recursive approach, not tested.

function splitArray(array, parts, out) 
 var
 len = array.length
 , partLen

 if (parts < len) 
 partLen = Math.ceil(len / parts);
 out.push(array.slice(0, partLen));
 if (parts > 1) 
 splitArray(array.slice(partLen), parts - 1, out);
 
 else 
 out.push(array);
 

Another recursive works quite well, it is less ugly

function nSmaller(num, arr, sliced) ;
 if(num === 0) 
 return sliced;
 

 var len = arr.length,
 point = Math.ceil(len/num),
 nextArr = arr.slice(point);

 mySliced.push(arr.slice(0, point));
 nSmaller(num-1, nextArr, mySliced);

 return(mySliced);

Probably the cleaner approach would be the following (without using any other library) :

var myArray = ;
for(var i=0; i<100; i++)
 myArray.push(i+1);

console.log(myArray);

function chunk(arr, size)
 var chunkedArr = ;
 var noOfChunks = Math.ceil(arr.length/size);
 console.log(noOfChunks);
 for(var i=0; i<noOfChunks; i++)
 chunkedArr.push(arr.slice(i*size, (i+1)*size));
 
 return chunkedArr;


var chunkedArr = chunk(myArray, 3);
console.log(chunkedArr);

I have created my own array which is to be chunked. You can find the code here

Also we have a method "chunk" in the lodash library which is of great use. Hope that helps

function splitArray(arr, numOfParts = 10)
 const splitedArray = 
 for (let i = 0; i < numOfParts;i++) 
 const numOfItemsToSplice = arr.length / 10;
 splitedArray.push(arr.splice(0, numOfItemsToSplice))
 
 return splitedArray;
 

I made it this way, it works...

function splitArray(array, parts) 
 if (parts< array.length && array.length > 1 && array != null) 
 var newArray = ;
 var counter1 = 0;
 var counter2 = 0;

 while (counter1 < parts) 
 newArray.push();
 counter1 += 1;
 

 for (var i = 0; i < array.length; i++) 
 newArray[counter2++].push(array[i]);
 if (counter2 > parts - 1)
 counter2 = 0;
 

 return newArray;
 else 
 return array;

check my version of this array split

// divide array
Array.prototype.divideIt = function(d)
 if(this.length <= d) return this;
 var arr = this,
 hold = ,
 ref = -1;
 for(var i = 0; i < arr.length; i++)
 if(i % d === 0)
 ref++;
 
 if(typeof hold[ref] === 'undefined')
 hold[ref] = ;
 
 hold[ref].push(arr[i]);
 

 return hold;
;

if you know wanna set child_arrays.length then i think this solution best:

function sp(size, arr) //size - child_array.length
 var out = ,i = 0, n= Math.ceil((arr.length)/size); 
 while(i < n) out.push(arr.splice(0, (i==n-1) && size < arr.length ? arr.length: size)); i++; 
 return out;

call fn:
sp(2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) //2 - child_arrat.length

answer:
[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11]

Just use lodash' chunk function to split the array into smaller arrays https://lodash.com/docs#chunk No need to fiddle with the loops anymore!

If you can use lodash and would like a functional programming approach, here is what I come up with:

const _ = require('lodash')

function splitArray(array, numChunks) 
 return _.reduce(_.range(numChunks), (array, result, numChunks, chunkIndex) => 
 const numItems = Math.ceil(array.length / numChunks)
 const items = _.take(array, numItems)
 result.push(items)
 return 
 array: _.drop(array, numItems),
 result,
 numChunks: numChunks - 1
 
 , 
 array,
 result: ,
 numChunks
 ).result
 

all above might work fine, but what if you have associative array with strings as keys?

objectKeys = Object.keys;

arraySplit(arr, n) 
 let counter = 0;
 for (const a of this.objectKeys(arr)) 
 this.arr[(counter%n)][a] = arr[a];
 counter++;
 

function parseToPages(elements, pageSize = 8) 
 var result = ;
 while (elements.length) 
 result.push(elements.splice(0, pageSize));
 
 return result;