下面是一个使用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); 

试试这个:

var oldArray =[“香蕉”、“橙色”,“柠檬”、“苹果”、“芒果”,“香蕉”,“橙色”,“柠檬”、“苹果”、“芒果”,“香蕉”,“橙色”,“柠檬”、“苹果”、“芒果”,“香蕉”,“橙色”,“柠檬”、“苹果”、“芒果”,“香蕉”,“橙色”,“柠檬”、“苹果”、“芒果”); var newArray = []; 而(oldArray.length) { 让start = 0; 让end = 10; newArray.push (oldArray。片(开始、结束)); oldArray。拼接(开始、结束); ｝ console.log (newArray);

现在你可以使用lodash的chunk函数将数组分割成更小的数组https://lodash.com/docs#chunk不再需要摆弄循环了!

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

功能块(加勒比海盗,n) { var r = Array(Math.ceil(arr.length/n)).fill(); 返回r.map((e,i) => arr。片(我* n * n + n)); ｝ arr = Array.from({length: 31}，(_，i) => i+1); Res = chunk(arr,7); console.log (JSON.stringify (res));

到目前为止还不错，但我们仍然可以进一步简化上面的片段。

var chunk = （a，n） => Array.from（{length： Math.ceil（a.length/n）}， （_，i） => a.slice（i*n， i*n+n））， arr = Array.from（{length： 31}，（_，i） => i+1）， res = chunk（arr，7）; console.log（JSON.stringify（res））;

我创建了以下JSFiddle来演示我解决您的问题的方法。

(function() { // Sample arrays var //elements = ["0", "1", "2", "3", "4", "5", "6", "7"], elements = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43"]; var splitElements = [], delimiter = 10; // Change this value as needed // parameters: array, number of elements to split the array by if(elements.length > delimiter){ splitElements = splitArray(elements, delimiter); } else { // No need to do anything if the array's length is less than the delimiter splitElements = elements; } //Displaying result in console for(element in splitElements){ if(splitElements.hasOwnProperty(element)){ console.log(element + " | " + splitElements[element]); } } })(); function splitArray(elements, delimiter) { var elements_length = elements.length; if (elements_length > delimiter) { var myArrays = [], // parent array, used to store each sub array first = 0, // used to capture the first element in each sub array index = 0; // used to set the index of each sub array for (var i = 0; i < elements_length; ++i) { if (i % delimiter === 0) { // Capture the first element of each sub array from the original array, when i is a modulus factor of the delimiter. first = i; } else if (delimiter - (i % delimiter) === 1) { // Build each sub array, from the original array, sliced every time the i one minus the modulus factor of the delimiter. index = (i + 1) / delimiter - 1; myArrays[index] = elements.slice(first, i + 1); } else if(i + 1 === elements_length){ // Build the last sub array which contain delimiter number or less elements myArrays[index + 1] = elements.slice(first, i + 1); } } // Returned is an array of arrays return myArrays; } }

首先，我有两个例子:一个数组少于8个元素，另一个数组多于8个元素(注释你不想使用的哪个数组)。

然后检查数组的大小，这很简单，但对于避免额外的计算是必要的。从这里开始，如果数组满足条件(数组大小为>分隔符)，我们将移动到splitArray函数。

splitArray函数接受分隔符(即8，因为这是分隔符)和数组本身。由于我们经常重用数组长度，所以我将它缓存在一个变量中，以及第一个和最后一个变量中。

First表示数组中第一个元素的位置。这个数组是由8个元素组成的数组。为了确定第一个元素，我们使用模算子。

myArrays是数组的数组。其中，我们将在每个索引处存储大小为8或更小的子数组。这是下面算法中的关键策略。

index表示myArrays变量的索引。每次存储8个或更少元素的子数组时，都需要将其存储在相应的索引中。如果我们有27个元素，那就意味着4个数组。第一个、第二个和第三个数组各有8个元素。最后一个只包含3个元素。所以index分别是0 1 2和3。

棘手的部分仅仅是计算出数学并尽可能优化它。例如，else if (delimiter - (i % delimiter) === 1)这是为了找到数组中应该包含的最后一个元素，当数组将被满时(例如:包含10个元素)。

这段代码适用于每一个场景，您甚至可以更改分隔符以匹配您想要获得的任何数组大小。很甜蜜吧:-)

有什么问题吗?请在下方评论中提问。

使用发电机

函数*块(arr, n) { 对于(设I = 0;I < arrr .length;I += n) { 加勒比海盗。Slice (i, i + n); ｝ ｝ let someArray = [0,1,2,3,4,5,6,7,8,9] console.log([…块(someArray, 2)]) / /[[0, 1],[2、3],[4,5],[6、7],[8 9]]

可以像这样用Typescript输入:

function* chunks<T>(arr: T[], n: number): Generator<T[], void> {
  for (let i = 0; i < arr.length; i += n) {
    yield arr.slice(i, i + n);
  }
}