这里有一个更具体的案例，有人可能会觉得有价值。我还没看到这里提到过。

如果你不想要固定/均匀的数据块大小，而是想要指定拆分数组的下标怎么办?在这种情况下，你可以使用这个:

const splitArray = (array = [], splits = []) => {
  array = [...array]; // make shallow copy to avoid mutating original
  const chunks = []; // collect chunks
  for (const split of splits.reverse()) chunks.push(array.splice(split)); // go backwards through split indices and lop off end of array
  chunks.push(array); // add last remaining chunk (at beginning of array)
  return chunks.reverse(); // restore chunk order
};

然后:

splitArray([1, 2, 3, 4, 5, 6, 7, 8, 9], [4, 6]) 
// [ [1, 2, 3, 4] , [5, 6] , [7, 8, 9] ]

请注意，如果你给它非升序/重复/负/非整数/等分割索引，这将会发生有趣的事情。您可以为这些边缘情况添加检查(例如array .from(new Set(array))来消除重复。

一个有效的解决方案是通过indexChunk将解决方案与slice和push连接起来，解决方案被分割成块:

function splitChunks(sourceArray, chunkSize) { if(chunkSize <= 0) throw "chunkSize must be greater than 0"; let result = []; for (var i = 0; i < sourceArray.length; i += chunkSize) { result[i / chunkSize] = sourceArray.slice(i, i + chunkSize); } return result; } let ar1 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]; console.log("Split in chunks with 4 size", splitChunks(ar1, 4)); console.log("Split in chunks with 7 size", splitChunks(ar1, 7));

下面是一个使用reduce的ES6版本

const perChunk = 2 //每个chunk有2个项目 const inputArray = ['a'，'b'，'c'，'d'，'e'] const result = inputArray。reduce((resultArray, item, index) => { const chunkIndex = Math.floor(index/perChunk) 如果(! resultArray [chunkIndex]) { resultArray[chunkIndex] =[] //启动一个新的chunk ｝ resultArray [chunkIndex] .push(项) 返回resultArray }, []) console.log(结果);// result: [['a'，'b']， ['c'，'d']， ['e']]]

并且您已经准备好连接进一步的映射/缩减转换。 输入数组保持不变

如果你喜欢更短但可读性较差的版本，你可以在混合中添加一些concat，以获得相同的最终结果:

inputArray.reduce((all,one,i) => {
   const ch = Math.floor(i/perChunk); 
   all[ch] = [].concat((all[ch]||[]),one); 
   return all
}, [])

你可以使用余数运算符将连续的项放入不同的块中:

const ch = (i % perChunk); 

这里是一个仅使用递归和slice()的非突变解决方案。

const splitToChunks = (arr, chunkSize, acc = []) => (
    arr.length > chunkSize ?
        splitToChunks(
            arr.slice(chunkSize),
            chunkSize,
            [...acc, arr.slice(0, chunkSize)]
        ) :
        [...acc, arr]
);

然后简单地像splitToChunks([1,2,3,4,5]， 3)一样使用它来获得[[1,2,3]，[4,5]]。

这里有一个小提琴供你尝试:https://jsfiddle.net/6wtrbx6k/2/

下面是使用reduce()方法的另一个解决方案，尽管与其他示例略有不同。希望我的解释也能更清楚一点。

Var arr = [0,1,2,3,4,5,6,7]; var chunkSize = 3; Arr = Arr。Reduce ((acc, item, idx) => { Let group = acc.pop(); 如果(集团。长度== chunkSize) { acc.push(集团); Group = []; ｝ group.push(项); acc.push(集团); 返回acc; }, [[]]); console.log (arr);//打印[[0,1,2]，[3,4,5]，[6,7]]

解释

我们称之为reducer，它对数组中的每一项都使用pop()获取累加器的最后一项。记住，这个项是一个数组，它将最多为chunkSize数量的项进行分组(在本例中为3)。

当且仅当该组的数组长度等于chunksize时，我们需要将该组重新插入到累加器中并创建一个新组。

然后将当前项推入我们的组数组(它可能已经包含前面步骤中的0、1或2个项)。将当前项插入组后，我们需要将组重新插入到更大的集合中。

该过程将重复进行，直到遍历arr中的所有项。

注意，我们还使用[[]]为减速器提供了数组中空数组的起始值。

这是我能想到的最有效、最直接的解决方案:

function chunk(array, chunkSize) {
    let chunkCount = Math.ceil(array.length / chunkSize);
    let chunks = new Array(chunkCount);
    for(let i = 0, j = 0, k = chunkSize; i < chunkCount; ++i) {
        chunks[i] = array.slice(j, k);
        j = k;
        k += chunkSize;
    }
    return chunks;
}