你可以使用Array.prototype.reduce函数在一行中完成这项工作。

让arr = [1,2,3,4]; 函数块(arr, size) ｛ 令result = arr。减少((行，键，索引)=>(索引%大小== 0 ?rows.push([主要]):行[rows.length-1] .push(关键))& &行,[]); 返回结果; ｝ console.log(块(arr), 2));

使用来自lodash的chunk

lodash.chunk(arr,<size>).forEach(chunk=>{
  console.log(chunk);
})

使用array .prototype.splice()并拼接它，直到数组有元素。

Array.prototype.chunk = function(size) { Let result = []; 而(this.length) { result.push(这一点。拼接(0,大小)); ｝ 返回结果; ｝ Const arr = [1,2,3,4,5,6,7,8,9]; console.log (arr.chunk (2));

更新

array .prototype.splice()填充原始数组，在执行chunk()之后，原始数组(arr)变成[]。

如果你想保持原始数组不变，那就复制arr数据到另一个数组，然后做同样的事情。

Array.prototype.chunk = function(size) { Let data =[…this]; Let result = []; 而(data.length) { result.push(数据。拼接(0,大小)); ｝ 返回结果; ｝ Const arr = [1,2,3,4,5,6,7,8,9]; console.log(分块:,arr.chunk (2)); console.log(“原始”,arr);

附注:感谢@mts-knn提到这件事。

当前排名靠前的答案存在的问题是，它们产生了不平衡的数据块。例如，当前接受的答案将把一个101个元素的数组分布为10个大小为10的块，后面是一个大小为1的块。

使用一些模块化算法可以创建统一的块大小，差异永远不会超过1:

函数split_array(a, nparts) { const quot = Math.floor;长度/ nparts) Const rem = a.length % nparts Var部件= [] For (var I = 0;I < nparts;+ + i) { const begin = i * quot +数学。分钟(rem,我) Const end = begin + quot + (i < rem) parts.push (a。片(开始、结束) ｝ 返回部分 ｝ Var chunk = split_array([1,2,3,4,5,6,7,8,9,10]， 3) console.log (JSON.stringify(块)

输出:

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

(摘自相关答案)

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

远非最快的性能，但我只是觉得好笑，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]]

使用Array.prototype.reduce()的另一个解决方案:

Const chunk = (array, size) => 数组中。Reduce ((acc， _， i) => { If (i % size === 0) ac .push(数组。切片(i, i + size)) 返回acc }, []) / /使用方法: Const数= [1,2,3,4,5,6,7,8,9,10] Const chunked = chunk(number, 3) console.log(分块)

这个解决方案与Steve Holgado的解决方案非常相似。但是，因为这个解决方案没有利用数组扩展，也没有在reducer函数中创建新数组，所以它比其他解决方案更快(参见jsPerf test)，而且主观上更可读(语法更简单)。

在每n次迭代(其中n = size;从第一次迭代开始)，累加器数组(acc)附加了数组的一个块(array。Slice (i, i + size))，然后返回。在其他迭代中，累加器数组按原样返回。

如果size为零，该方法返回一个空数组。如果size为负，则该方法返回破碎的结果。因此，如果在您的情况下需要，您可能需要对负的或非正的大小值进行处理。

如果在你的情况下速度很重要，一个简单的for循环将比使用reduce()更快(参见jsPerf测试)，一些人可能会发现这种风格更易于阅读:

function chunk(array, size) {
  // This prevents infinite loops
  if (size < 1) throw new Error('Size must be positive')

  const result = []
  for (let i = 0; i < array.length; i += size) {
    result.push(array.slice(i, i + size))
  }
  return result
}