编辑:@mblase75在我写我的答案时在前面的答案上添加了更简洁的代码，所以我建议使用他的解决方案。

你可以使用这样的代码:

var longArray = ["Element 1","Element 2","Element 3", /*...*/];
var smallerArrays = []; // will contain the sub-arrays of 10 elements each
var arraySize = 10;
for (var i=0;i<Math.ceil(longArray.length/arraySize);i++) {
    smallerArrays.push(longArray.slice(i*arraySize,i*arraySize+arraySize));
}

修改arraySize的值可以改变较小数组的最大长度。

array.slice()方法可以根据需要从数组的开头、中间或结尾提取切片，而不需要改变原始数组。

const chunkSize = 10;
for (let i = 0; i < array.length; i += chunkSize) {
    const chunk = array.slice(i, i + chunkSize);
    // do whatever
}

最后一个块可能小于chunkSize。例如，当给定一个包含12个元素的数组时，第一个块将有10个元素，第二个块只有2个。

注意，chunkSize为0将导致无限循环。

这就是我对这个话题的贡献。我想.reduce()是最好的方法。

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); Res = segment(arr,7); console.log (JSON.stringify (res));

但是上面的实现不是很有效，因为.reduce()运行在所有arr函数中。一个更有效的方法(非常接近最快的强制解决方案)是，迭代缩减(要分块)数组，因为我们可以通过Math.ceil(arr/n);提前计算它的大小。一旦我们有一个空的结果数组，比如array (Math.ceil(arr.length/n)).fill();剩下的是将arr数组的切片映射到它。

功能块(加勒比海盗,n) { var r = Array(Math.ceil(arr.length/n)).fill(); 返回r.map((e,i) => arr。片(我* n * n + n)); ｝ arr = Array.from({length: 31}，(_，i) => i+1); Res = chunk(arr,7); console.log (JSON.stringify (res));

到目前为止还不错，但我们仍然可以进一步简化上面的片段。

var chunk = （a，n） => Array.from（{length： Math.ceil（a.length/n）}， （_，i） => a.slice（i*n， i*n+n））， arr = Array.from（{length： 31}，（_，i） => i+1）， res = chunk（arr，7）; console.log（JSON.stringify（res））;

一行程序

const chunk = (a,n)=>[...Array(Math.ceil(a.length/n))].map((_,i)=>a.slice(n*i,n+n*i));

为打印稿

const chunk = <T>(arr: T[], size: number): T[][] =>
  [...Array(Math.ceil(arr.length / size))].map((_, i) =>
    arr.slice(size * i, size + size * i)
  );

DEMO

const块= (n) = >[…]数组(Math.ceil (a.length / n))) . map ((_, i) = > a.slice (n * n + n * i)); document . write (JSON。Stringify (chunk([1,2,3,4]， 2)));

按组数分组

const part=(a,n)=>[...Array(n)].map((_,i)=>a.slice(i*Math.ceil(a.length/n),(i+1)*Math.ceil(a.length/n)));

为打印稿

const part = <T>(a: T[], n: number): T[][] => {
  const b = Math.ceil(a.length / n);
  return [...Array(n)].map((_, i) => a.slice(i * b, (i + 1) * b));
};

DEMO

Const部分= (a, n) => { const b = Math.ceil(a。长度/ n); 返回数组(n)[…]。Map ((_， i) => .slice(i * b， (i + 1) * b)); }; document . write (JSON。Stringify (part([1,2,3,4,5,6]， 2))+'<br/>'); document . write (JSON。Stringify (part([1,2,3,4,5,6,7]， 2)));

这是一个带有尾递归和数组解构的版本。

远非最快的性能，但我只是觉得好笑，js现在可以做到这一点。即使它没有为此进行优化:(

const getChunks = (arr, chunk_size, acc = []) => {
    if (arr.length === 0) { return acc }
    const [hd, tl] = [ arr.slice(0, chunk_size), arr.slice(chunk_size) ]
    return getChunks(tl, chunk_size, acc.concat([hd]))
}

// USAGE
const my_arr = [1,2,3,4,5,6,7,8,9]
const chunks = getChunks(my_arr, 2)
console.log(chunks) // [[1,2],[3,4], [5,6], [7,8], [9]]

我试过递归函数…

const chunk = (arr, n) =>
    arr.length ? [arr.slice(0, n), ...chunk(arr.slice(n), n)] : [];

……这很好，很短，但似乎是@AymKdn回答1000个元素用时的256倍，10000个元素用时的1058倍!