一行程序

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)));

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将导致无限循环。

对于功能性的解决方案，使用Ramda:

其中，popularProducts是输入数组，5是数据块大小

导入splitEvery from 'ramda/src/splitEvery' popularProducts splitEvery(5)。Map ((chunk, i) => { //用chunk做一些事情 })

使用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
}

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

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

这里是整洁和优化的实现chunk()函数。假设默认块大小为10。

var chunk = function(list, chunkSize) {
  if (!list.length) {
    return [];
  }
  if (typeof chunkSize === undefined) {
    chunkSize = 10;
  }

  var i, j, t, chunks = [];
  for (i = 0, j = list.length; i < j; i += chunkSize) {
    t = list.slice(i, i + chunkSize);
    chunks.push(t);
  }

  return chunks;
};

//calling function
var list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
var chunks = chunk(list);