Como dividir um array longo em arrays menores, com JavaScript

Eu tenho uma série de e-mails (pode ser apenas um e-mail ou 100 e-mails), e eu preciso enviar o array com um pedido de ajax (que eu sei fazer), mas só posso enviar um array que tenha 10 ou menos e-mails nele. Portanto, se houver uma matriz original de 20 e-mails, precisarei dividi-los em duas matrizes de 10 cada. ou se houver 15 e-mails no array original, 1 matriz de 10 e outra matriz de 5. Estou usando o jQuery, qual seria a melhor maneira de fazer isso?

Não use jquery … use javascript simples

var a = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]; var b = a.splice(0,10); //a is now [11,12,13,14,15]; //b is now [1,2,3,4,5,6,7,8,9,10]; 

Você pode fazer um loop para obter o comportamento desejado.

 var a = YOUR_ARRAY; while(a.length) { console.log(a.splice(0,10)); } 

Isso daria 10 elementos de cada vez … se você disser 15 elementos, você obteria 1-10, o 11-15 como você queria.

 var size = 10; var arrayOfArrays = []; for (var i=0; i 

Ao contrário de splice() , slice() não é destrutivo para o array original.

Basta percorrer o array, combinando até que tudo seja consumido.

 var a = ['a','b','c','d','e','f','g'] , chunk while (a.length > 0) { chunk = a.splice(0,3) console.log(chunk) } 

saída

 [ 'a', 'b', 'c' ] [ 'd', 'e', 'f' ] [ 'g' ] 

Você pode usar o lodash: https://lodash.com/docs

 _.chunk(['a', 'b', 'c', 'd'], 2); // → [['a', 'b'], ['c', 'd']] 

Supondo que você não queira destruir o array original, você pode usar um código como este para dividir o array longo em arrays menores que você pode então iterar:

 var longArray = []; // assume this has 100 or more email addresses in it var shortArrays = [], i, len; for (i = 0, len = longArray.length; i < len; i += 10) { shortArrays.push(longArray.slice(i, i + 10)); } // now you can iterate over shortArrays which is an // array of arrays where each array has 10 or fewer // of the original email addresses in it for (i = 0, len = shortArrays.length; i < len; i++) { // shortArrays[i] is an array of email addresss of 10 or less } 

Como um complemento à resposta do @jyore, e caso você ainda queira manter o array original:

 var originalArray = [1,2,3,4,5,6,7,8]; var splitArray = function (arr, size) { var arr2 = arr.slice(0), arrays = []; while (arr2.length > 0) { arrays.push(arr2.splice(0, size)); } return arrays; } splitArray(originalArray, 2); // originalArray is still = [1,2,3,4,5,6,7,8]; 

Eu gostaria de compartilhar minha solução também. É um pouco mais detalhado, mas funciona também.

 var data = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]; var chunksize = 4; var chunks = []; data.forEach((item)=>{ if(!chunks.length || chunks[chunks.length-1].length == chunksize) chunks.push([]); chunks[chunks.length-1].push(item); }); console.log(chunks); 

Saída (formatada):

 [ [ 1, 2, 3, 4], [ 5, 6, 7, 8], [ 9, 10, 11, 12], [13, 14, 15 ] ] 

Outro método:

 var longArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; var size = 2; var newArray = new Array(Math.ceil(longArray.length / size)).fill("") .map(function() { return this.splice(0, size) }, longArray.slice()); // newArray = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]; 

Isso não afeta o array original, pois uma cópia, feita usando slice, é passada para o argumento ‘this’ do mapa.

Outra implementação:

 const arr = ["H", "o", "w", " ", "t", "o", " ", "s", "p", "l", "i", "t", " ", "a", " ", "l", "o", "n", "g", " ", "a", "r", "r", "a", "y", " ", "i", "n", "t", "o", " ", "s", "m", "a", "l", "l", "e", "r", " ", "a", "r", "r", "a", "y", "s", ",", " ", "w", "i", "t", "h", " ", "J", "a", "v", "a", "S", "c", "r", "i", "p", "t"]; const size = 3; const res = arr.reduce((acc, curr, i) => { if ( !(i % size) ) { // if index is 0 or can be divided by the `size`... acc.push(arr.slice(i, i + size)); // ..push a chunk of the original array to the accumulator } return acc; }, []); // => [["H", "o", "w"], [" ", "t", "o"], [" ", "s", "p"], ["l", "i", "t"], [" ", "a", " "], ["l", "o", "n"], ["g", " ", "a"], ["r", "r", "a"], ["y", " ", "i"], ["n", "t", "o"], [" ", "s", "m"], ["a", "l", "l"], ["e", "r", " "], ["a", "r", "r"], ["a", "y", "s"], [",", " ", "w"], ["i", "t", "h"], [" ", "J", "a"], ["v", "a", "S"], ["c", "r", "i"], ["p", "t"]] 

NB – Isso não modifica a matriz original.

Ou, se preferir um método funcional, imutável e autocontido:

 function splitBy(size, list) { return list.reduce((acc, curr, i, self) => { if ( !(i % size) ) { return [ ...acc, self.slice(i, i + size), ]; } return acc; }, []); } 

Você pode dar uma olhada neste código. Simples e eficaz.

 function chunkArrayInGroups(array, unit) { var results = [], length = Math.ceil(array.length / unit); for (var i = 0; i < length; i++) { results.push(array.slice(i * unit, (i + 1) * unit)); } return results; } chunkArrayInGroups(["a", "b", "c", "d"], 2); 

Aqui está um simples forro

 var segment = (arr, n) => arr.reduce((r,e,i) => i%n ? (r[r.length-1].push(e), r) : (r.push([e]), r), []), arr = Array.from({length: 31}).map((_,i) => i+1); console.log(segment(arr,7)); 

Se você quiser um método que não modifique a matriz existente, tente isto:

 let oldArray = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]; let newArray = []; let size = 3; // Size of chunks you are after let j = 0; // This helps us keep track of the child arrays for (var i = 0; i < oldArray.length; i++) { if (i % size === 0) { j++ } if(!newArray[j]) newArray[j] = []; newArray[j].push(oldArray[i]) } 

Outra implementação, usando Array.reduce (acho que é o único que falta!):

 const splitArray = (arr, size) => { if (size === 0) { return []; } return arr.reduce((split, element, index) => { index % size === 0 ? split.push([element]) : split[Math.floor(index / size)].push(element); return split; }, []); }; 

Como muitas soluções acima, esta não é destrutiva. Retornar um array vazio quando o tamanho for 0 é apenas uma convenção. Se o bloco if for omitido, você receberá um erro, que pode ser o que você deseja.

 function chunkArrayInGroups(arr, size) { var newArr=[]; for (var i=0; arr.length>size; i++){ newArr.push(arr.splice(0,size)); } newArr.push(arr.slice(0)); return newArr; } chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3);