将数组拆分为大块


515

假设我有一个如下所示的Javascript数组:

["Element 1","Element 2","Element 3",...]; // with close to a hundred elements.

什么方法适合将数组分块(拆分)为更小的数组,最多可以有10个元素?


另请参阅如何使用underscore.js(以及链接问题中的许多
重复对象


24
对于lodash用户,您正在寻找_.chunk
Ulysse BN

2
我只是试过了const chunk = (arr, n) => arr.length ? [arr.slice(0, n), ...chunk(arr.slice(n), n)] : [],这很不错,也很简短,但似乎只要@AymKdn回答1000个元素,它就需要大约256倍;而如果10,000个元素的话,它就需要1058倍!
Toph

如果你需要的最后一块也是最小尺寸,这里的选项:stackoverflow.com/questions/57908133/...
艾哈迈德·切廷

Answers:


640

array.slice方法可以从一开始,中间,或自己需要的任何目的数组的结束提取切片,在不改变原来的数组。

var i,j,temparray,chunk = 10;
for (i=0,j=array.length; i<j; i+=chunk) {
    temparray = array.slice(i,i+chunk);
    // do whatever
}

19
请记住,如果这是一个实用程序功能的断言对chunk0。(无限循环)
史蒂文·卢

19
不,最后一个块应该比其他块小。
Blazemonger,2014年

7
确实是@Blazemonger!下次,我实际上将自己尝试一下,然后再得出结论。我以为(错误地)认为将输入传递到array.slice中超出了数组的范围是一个问题,但它确实完美!
rysqui 2014年

55
对于单行(链爱好者)const array_chunks = (array, chunk_size) => Array(Math.ceil(array.length / chunk_size)).fill().map((_, index) => index * chunk_size).map(begin => array.slice(begin, begin + chunk_size));
КонстантинВан

8
你为什么需要j?首先,我认为这是一种优化,但实际上比for(i = 0; i <array.length; i ++){}慢。–
Alex

149

修改自dbaseman的答案:https ://stackoverflow.com/a/10456344/711085

Object.defineProperty(Array.prototype, 'chunk_inefficient', {
  value: function(chunkSize) {
    var array = this;
    return [].concat.apply([],
      array.map(function(elem, i) {
        return i % chunkSize ? [] : [array.slice(i, i + chunkSize)];
      })
    );
  }
});

console.log(
  [1, 2, 3, 4, 5, 6, 7].chunk_inefficient(3)
)
// [[1, 2, 3], [4, 5, 6], [7]]


次要附录

我应该指出,以上是我认为不那么优雅的解决方法Array.map。它基本上执行以下操作,其中〜是串联:

[[1,2,3]]~[]~[]~[] ~ [[4,5,6]]~[]~[]~[] ~ [[7]]

它具有与以下方法相同的渐近运行时间,但可能由于构建空列表而导致更差的恒定因子。可以这样重写(大部分与Blazemonger的方法相同,这就是为什么我最初没有提交此答案的原因):

更有效的方法:

// refresh page if experimenting and you already defined Array.prototype.chunk

Object.defineProperty(Array.prototype, 'chunk', {
  value: function(chunkSize) {
    var R = [];
    for (var i = 0; i < this.length; i += chunkSize)
      R.push(this.slice(i, i + chunkSize));
    return R;
  }
});

console.log(
  [1, 2, 3, 4, 5, 6, 7].chunk(3)
)


如今,我的首选方法是上述方法或以下方法之一:

Array.range = function(n) {
  // Array.range(5) --> [0,1,2,3,4]
  return Array.apply(null,Array(n)).map((x,i) => i)
};

Object.defineProperty(Array.prototype, 'chunk', {
  value: function(n) {

    // ACTUAL CODE FOR CHUNKING ARRAY:
    return Array.range(Math.ceil(this.length/n)).map((x,i) => this.slice(i*n,i*n+n));

  }
});

演示:

> JSON.stringify( Array.range(10).chunk(3) );
[[1,2,3],[4,5,6],[7,8,9],[10]]

或者,如果您不希望使用Array.range函数,那么实际上它只是单线的(不包括绒毛):

var ceil = Math.ceil;

Object.defineProperty(Array.prototype, 'chunk', {value: function(n) {
    return Array(ceil(this.length/n)).fill().map((_,i) => this.slice(i*n,i*n+n));
}});

要么

Object.defineProperty(Array.prototype, 'chunk', {value: function(n) {
    return Array.from(Array(ceil(this.length/n)), (_,i)=>this.slice(i*n,i*n+n));
}});

41
嗯,我避免弄乱原型,因为从chunk数组上调用函数所带来的凉爽感觉并没有真正超过您添加的额外复杂性以及与内置原型弄乱可能引起的细微错误。
Gordon Gustafson,2012年

12
他没有弄乱他们,而是将它们扩展为Arrays。我知道永远不要接触Object.prototype,因为那样会冒泡到所有对象(一切),但是对于此特定于Array的函数,我看不到任何问题。
rlemon 2012年

很肯定这应该是array.map(function(i)没有array.map(function(elem,i),虽然
奈杰尔天使

3
根据mozilla开发人员网站上的兼容性图表,适用于IE9 +的Array.map。小心。
Maikel D

小心通过浮- 7.5型数字-导致不可预知的块
半乳糖的Bracha

103

这是使用reduce的ES6版本

var perChunk = 2 // items per chunk    

var inputArray = ['a','b','c','d','e']

var result = inputArray.reduce((resultArray, item, index) => { 
  const chunkIndex = Math.floor(index/perChunk)

  if(!resultArray[chunkIndex]) {
    resultArray[chunkIndex] = [] // start a new chunk
  }

  resultArray[chunkIndex].push(item)

  return resultArray
}, [])

console.log(result); // 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
}, [])

这似乎是最简洁的解决方案。什么是chunkIndex = Math.floor(index / perChunk)得到什么?是平均值吗?
me-me

5/2 = 2.5Math.floor(2.5) = 2因此与索引5项将放置在桶2
安德烈- [R

谢谢Andrei R. Ah,它经过了0-2。那么,这在数学上又叫什么?我想我的意思是我永远不会想到将索引/每个索引除以2来获取每个切片的索引。因此,我想尽全力以赴,因为我很喜欢它,但对Math的术语并不完全了解。我通常这样做是为了获得总数的平均值,但这看起来有所不同。
me-me

与其他解决方案相比,该解决方案效率低下,因为您需要遍历每个元素。
JP de la Torre

您是正确的@JPdelaTorre,它的效率可能不如对数组进行切片的解决方案那么有效,但是您在这里要分叉。根据该定义,列出的大多数答案都是无效的。
Andrei R

102

如果您不知道谁在使用您的代码(第三方,同事,您自己等),请尝试避免破坏原生原型,包括Array.prototype。

有一些方法可以安全地扩展原型(但不是在所有浏览器中),并且可以安全地使用从扩展的原型创建的对象,但是更好的经验法则是遵循“最少惊讶原则”并完全避免这些做法。

如果您有时间,请观看Andrew Dupont在JSConf 2011上的演讲“一切都允许:扩展内置插件”,以获取有关此主题的精彩讨论。

但是回到问题所在,尽管上述解决方案可以工作,但它们过于复杂,需要不必要的计算开销。这是我的解决方案:

function chunk (arr, len) {

  var chunks = [],
      i = 0,
      n = arr.length;

  while (i < n) {
    chunks.push(arr.slice(i, i += len));
  }

  return chunks;
}

// Optionally, you can do the following to avoid cluttering the global namespace:
Array.chunk = chunk;

25
新的js开发人员应该“避免与原始原型混为一谈”这句话的临时(即使不是永久的)纹身。
Jacob Dalton

2
我已经使用javascript多年了,几乎没有时间花时间去烦恼原型,在大多数调用函数中,从来没有像人们看到的那样进行修改。
1984年

2
我眼中最好的建议,最简单的理解和实施,非常感谢!
奥尔加·法伯

1
@JacobDalton我认为这是所有大学的错。人们认为OOP必须在任何地方使用。因此,他们害怕“仅创建功能”。他们希望确保将其放入某些内容中。即使这根本不合适。如果没有点符号,则没有“体系结构”。
Gherman

51

我在jsperf.com中测试了不同的答案。结果在此处可用:https : //web.archive.org/web/20150909134228/https : //jsperf.com/chunk-mtds

最快的功能(可从IE8使用)是这一功能:

function chunk(arr, chunkSize) {
  var R = [];
  for (var i=0,len=arr.length; i<len; i+=chunkSize)
    R.push(arr.slice(i,i+chunkSize));
  return R;
}

1
感谢@AymKdn进行此基准测试:非常有用!我使用的是拼接方法,它使Chrome v70浏览器崩溃,块大小为884432。使用您建议的“切片”方法,我的代码不再使浏览器的“渲染”过程崩溃。:)
Benny Neugebauer

34

我更喜欢使用拼接方法:

var chunks = function(array, size) {
  var results = [];
  while (array.length) {
    results.push(array.splice(0, size));
  }
  return results;
};

16
由于这种拼接解决方案会修改原始阵列,因此必须小心,因此请务必清楚记录其副作用。
bdrx

3
然后改用切片
mplungjan

@mplungjan使用切片时,结果将是一次又一次的相同数组。因此,如果不做更多修改,它实际上不是直接替代。
nietonfir

我要添加到此答案中的唯一一件事是原始数组的克隆。我会使用ES6的传播算子来做到这一点。var clone = [...array]然后对克隆的数组进行长度检查和拼接。
MauricioLeal

1
或者,如果您不能使用ES6功能,则只需array = array.slice()创建一个浅表副本即可。
3limin4t0r

34

ECMA 6中的一线

const [list,chuckSize] = [[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15], 6]

new Array(Math.ceil(list.length / chuckSize)).fill().map(_ => list.splice(0,chuckSize))

9
它修改了原始list数组
Jacka

6
使用.slice()轻松修复。 .map((_,i) => list.slice(i*chuckSize,i*chuckSize+chuckSize))
James Robey,

2
在JSPerf上,它比许多其他答案都具有更高的性能。
米卡·亨宁

30

旧问题:新答案!实际上,我正在研究此问题的答案,并且有一位朋友对此进行了改进!所以这里是:

Array.prototype.chunk = function ( n ) {
    if ( !this.length ) {
        return [];
    }
    return [ this.slice( 0, n ) ].concat( this.slice(n).chunk(n) );
};

[1,2,3,4,5,6,7,8,9,0].chunk(3);
> [[1,2,3],[4,5,6],[7,8,9],[0]]

14
依此类推,此方法的性能为O(N ^ 2),因此不应在代码的性能至关重要的部分或较长的数组中使用(特别是当数组的.length大小大于chunk-size时n)。如果这是一种惰性语言(与javascript不同),则此算法将不会受到O(N ^ 2)时间的困扰。就是说,递归实现是优雅的。您可能可以修改它以提高性能,方法是先定义一个递归的辅助函数array,position,然后调度:Array.prototype.chunk返回[您的辅助函数](...)
ninjagecko 2012年

感谢sensai赐予我我今晚一定要振奋精神的精神
被咬

1
还是...var chunk = (arr, n) => { if ( !arr.length ) return []; return [ arr.slice( 0, n ) ].concat( chunk(arr.slice(n), n) ) }
Ed Williams


20

有很多答案,但这是我使用的:

const chunk = (arr, size) =>
  arr
    .reduce((acc, _, i) =>
      (i % size)
        ? acc
        : [...acc, arr.slice(i, i + size)]
    , [])

// USAGE
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
chunk(numbers, 3)

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

首先,检查索引除以块大小时是否有余数。

如果还有余数,则只返回累加器数组。

如果没有余数,则索引可以被块大小整除,因此从原始数组中获取一个切片(从当前索引开始)并将其添加到累加器数组中。

因此,针对reduce的每次迭代返回的累加器数组如下所示:

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

好的解决方案和直观的迭代表示。我最终得到了一个非常类似的解决方案,该解决方案作为答案发布了:stackoverflow.com/a/60779547
mts knn

15

使用发电机

function* chunks(arr, n) {
 for(let i = 0; i < arr.length; i += n) {
     yield(arr.slice(i, i+n));
     }
}
let someArray = [0,1,2,3,4,5,6,7,8,9]
console.log([...chunks(someArray, 2)]) // [[0,1],[2,3],[4,5],[6,7],[8,9]]


3
我几乎对这个问题的所有答案感到惊讶,这些答案几乎都使用了生成器,或者以更复杂的方式使用了它们。此解决方案的简洁性和性能很好。
基思

14

好吧,让我们从一个相当紧的开始:

function chunk(arr, n) {
    return arr.slice(0,(arr.length+n-1)/n|0).
           map(function(c,i) { return arr.slice(n*i,n*i+n); });
}

像这样使用:

chunk([1,2,3,4,5,6,7], 2);

然后我们有这个紧密的reducer函数:

function chunker(p, c, i) {
    (p[i/this|0] = p[i/this|0] || []).push(c);
    return p;
}

像这样使用:

[1,2,3,4,5,6,7].reduce(chunker.bind(3),[]);

由于绑定this到数字时小猫会死亡,因此我们可以像这样手动手动计算:

// Fluent alternative API without prototype hacks.
function chunker(n) {
   return function(p, c, i) {
       (p[i/n|0] = p[i/n|0] || []).push(c);
       return p;
   };
}

像这样使用:

[1,2,3,4,5,6,7].reduce(chunker(3),[]);

然后,仍然非常紧凑的功能可以一次性完成所有工作:

function chunk(arr, n) {
    return arr.reduce(function(p, cur, i) {
        (p[i/n|0] = p[i/n|0] || []).push(cur);
        return p;
    },[]);
}

chunk([1,2,3,4,5,6,7], 3);

在iE8中不起作用。
Nadeemmnn Mohd

4
哈!我喜欢小猫的评论。抱歉,没有提供任何其他建设性的意见:)
29er

我会这样做的(p[i/n|0] || (p[i/n|0] = [])),所以如果没有必要,您就不要赋值...
yckart

12

我的目标是在纯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的荒谬的数组功能令人困惑:-)


我也这样写我的。如果您0从中删除,它仍然可以工作fill,这会使fill外观更加明智,恕我直言。
Coert Grobbelaar

12

我认为这是使用ES6语法的不错的递归解决方案:

const chunk = function(array, size) {
  if (!array.length) {
    return [];
  }
  const head = array.slice(0, size);
  const tail = array.slice(size);

  return [head, ...chunk(tail, size)];
};

console.log(chunk([1,2,3], 2));


9

为此https://www.npmjs.com/package/array.chunk创建了一个npm包

var result = [];

for (var i = 0; i < arr.length; i += size) {
  result.push(arr.slice(i, size + i));
}
return result;

使用TypedArray时

var result = [];

for (var i = 0; i < arr.length; i += size) {
  result.push(arr.subarray(i, size + i));
}
return result;

@ A1rPun我不好,我没有在此处添加评论。是的,没有slice方法TypedArray,我们可以subarray改用developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…–
zhiyelee

8

如果使用的EcmaScript版本> = 5.1,则可以实现chunk()使用具有O(N)复杂度的array.reduce()的功能版本:

function chunk(chunkSize, array) {
    return array.reduce(function(previous, current) {
        var chunk;
        if (previous.length === 0 || 
                previous[previous.length -1].length === chunkSize) {
            chunk = [];   // 1
            previous.push(chunk);   // 2
        }
        else {
            chunk = previous[previous.length -1];   // 3
        }
        chunk.push(current);   // 4
        return previous;   // 5
    }, []);   // 6
}

console.log(chunk(2, ['a', 'b', 'c', 'd', 'e']));
// prints [ [ 'a', 'b' ], [ 'c', 'd' ], [ 'e' ] ]

// nbr以上各项的说明:

  1. 如果先前值(即先前返回的块数组)为空,或者如果最后一个先前的块包含chunkSize项,则创建一个新块
  2. 将新块添加到现有块的数组中
  3. 否则,当前块是块数组中的最后一个块
  4. 将当前值添加到块中
  5. 返回修改后的块数组
  6. 通过传递空数组来初始化还原

固化基于chunkSize

var chunk3 = function(array) {
    return chunk(3, array);
};

console.log(chunk3(['a', 'b', 'c', 'd', 'e']));
// prints [ [ 'a', 'b', 'c' ], [ 'd', 'e' ] ]

您可以将chunk()函数添加到全局Array对象:

Object.defineProperty(Array.prototype, 'chunk', {
    value: function(chunkSize) {
        return this.reduce(function(previous, current) {
            var chunk;
            if (previous.length === 0 || 
                    previous[previous.length -1].length === chunkSize) {
                chunk = [];
                previous.push(chunk);
            }
            else {
                chunk = previous[previous.length -1];
            }
            chunk.push(current);
            return previous;
        }, []);
    }
});

console.log(['a', 'b', 'c', 'd', 'e'].chunk(4));
// prints [ [ 'a', 'b', 'c' 'd' ], [ 'e' ] ]


7
in coffeescript:

b = (a.splice(0, len) while a.length)

demo 
a = [1, 2, 3, 4, 5, 6, 7]

b = (a.splice(0, 2) while a.length)
[ [ 1, 2 ],
  [ 3, 4 ],
  [ 5, 6 ],
  [ 7 ] ]

a.splice(0,2)从a中删除a [0..1]的子数组,并返回子数组a [0..1]。我正在制作所有这些阵列中的一个阵列
Arpit Jain 2014年

2
我建议使用非破坏性slice()方法代替splice()
灰蓝色

7
results = []
chunk_size = 10
while(array.length > 0){
   results.push(array.splice(0, chunk_size))
}

1
不知道为什么不赞成这样做,但是代码可以使用一些解释。
jpaugh

2
因为拼接会破坏原始数组。
metalim

7

以下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)

6

这就是我对这个话题的贡献。我猜.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数组的切片映射到其中。

function chunk(arr,n){
  var r = Array(Math.ceil(arr.length/n)).fill();
  return r.map((e,i) => arr.slice(i*n, i*n+n));
}

arr = Array.from({length: 31},(_,i) => i+1);
res = chunk(arr,7);
console.log(JSON.stringify(res));



4

对于功能性解决方案,请使用Ramda

popularProducts输入数组在哪里,5块大小在哪里

import splitEvery from 'ramda/src/splitEvery'

splitEvery(5, popularProducts).map((chunk, i) => {
// do something with chunk

})


4

ES6单线方法基于Array.prototype reducepush方法:

const doChunk = (list, size) => list.reduce((r, v) =>
  (!r.length || r[r.length - 1].length === size ?
    r.push([v]) : r[r.length - 1].push(v)) && r
, []);

console.log(doChunk([0,1,2,3,4,5,6,7,8,9,10,11,12], 5));
// [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9], [10, 11, 12]]

4

ES6 Generator版本

function* chunkArray(array,size=1){
    var clone = array.slice(0);
    while (clone.length>0) 
      yield clone.splice(0,size); 
};
var a = new Array(100).fill().map((x,index)=>index);
for(const c of chunkArray(a,10)) 
    console.log(c);

使用const代替。
20КонстантинВан

4

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

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

4

ES6传播功能性#ohmy #ftw

const chunk =
  (size, xs) => 
    xs.reduce(
      (segments, _, index) =>
        index % size === 0 
          ? [...segments, xs.slice(index, index + size)] 
          : segments, 
      []
    );

console.log( chunk(3, [1, 2, 3, 4, 5, 6, 7, 8]) );


4

这是一个尾部调用优化的递归解决方案。

const splitEvery = (n, xs, y=[]) =>
  xs.length===0 ? y : splitEvery(n, xs.slice(n), y.concat([xs.slice(0, n)])) 

console.log(splitEvery(2, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))


4

使用arr.reduce()以下另一种解决方案:

const chunk = (arr, size) => (
  arr.reduce((acc, _, i) => {
    if (i % size === 0) acc.push(arr.slice(i, i + size))
    return acc
  }, [])
)

// Usage:
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
const chunked = chunk(numbers, 3)
console.log(chunked)

该解决方案与Steve Holgado解决方案非常相似。但是,由于此解决方案没有利用数组扩展,也没有在reducer函数中创建新的数组,因此与其他解决方案相比,它更快(请参阅jsPerf test)并且在主观上更具可读性(语法更简单)。

第n次迭代中(其中n = size;从第一次迭代开始),累加器数组(acc)会附加数组的一部分(arr.slice(i, i + size)),然后返回。在其他迭代中,累加器数组按原样返回。

如果size为零,则该方法返回一个空数组。如果size为负,则该方法返回错误的结果。因此,如果需要,您可能需要对负值或非正值进行一些处理size


如果速度对您而言很重要,那么简单的for循环会比使用速度快arr.reduce()(请参阅jsPerf test),并且有些人可能还会发现这种样式更易读:

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

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

2

编辑:@ 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以更改较小数组的最大长度。


2

这是仅使用递归和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/

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.