下面是使用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中的所有项。

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

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

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

下面的ES2015方法不需要定义函数，直接在匿名数组上工作(例如块大小为2):

[11,22,33,44,55].map((_, i, all) => all.slice(2*i, 2*i+2)).filter(x=>x.length)

如果你想为此定义一个函数，你可以这样做(改进K._对Blazemonger的回答的评论):

const array_chunks = (array, chunk_size) => array
    .map((_, i, all) => all.slice(i*chunk_size, (i+1)*chunk_size))
    .filter(x => x.length)

超级晚，但我解决了一个类似的问题，使用.join("")的方法将数组转换为一个巨大的字符串，然后使用regex将.match(/.{1,7}/)它转换为最大长度为7的子字符串数组。

const arr = ['abc', 'def', 'gh', 'ijkl', 'm', 'nopq', 'rs', 'tuvwx', 'yz'];
const arrayOfSevens = arr.join("").match(/.{1,7}/g);
// ["abcdefg", "hijklmn", "opqrstu", "vwxyz"]

看看这个在速度测试中如何与其他方法进行比较会很有趣吗

使用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提到这件事。

我的目标是在纯ES6中创建一个简单的非突变解决方案。javascript的特性使得在映射之前必须填充空数组:-(

function chunk(a, l) { 
    return new Array(Math.ceil(a.length / l)).fill(0)
        .map((_, n) => a.slice(n*l, n*l + l)); 
}

这个带有递归的版本似乎更简单，也更引人注目:

function chunk(a, l) { 
    if (a.length == 0) return []; 
    else return [a.slice(0, l)].concat(chunk(a.slice(l), l)); 
}

ES6中荒谬的弱数组函数可以制作出很好的谜题:-)