สมมติว่าฉันมีอาร์เรย์ Javascript ที่ดูดังต่อไปนี้:

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

มีวิธีการใดที่เหมาะสมที่จะทำการแยก (แบ่ง) อาเรย์ออกเป็นอาร์เรย์ขนาดเล็กจำนวนมากด้วยสมมติว่า 10 องค์ประกอบที่มากที่สุด

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
}

แก้ไขจากคำตอบโดย 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]]

มันมีเวลาทำงานแบบ asymptotic เช่นเดียวกับวิธีการด้านล่าง แต่อาจเป็นปัจจัยที่แย่ลงเนื่องจากการสร้างรายการที่ว่างเปล่า หนึ่งสามารถเขียนสิ่งนี้ดังนี้ (ส่วนใหญ่เหมือนกับวิธี 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));
}});

นี่คือรุ่น 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
}, [])

พยายามหลีกเลี่ยงการลอกเลียนแบบต้นแบบดั้งเดิมรวมถึง Array.prototype หากคุณไม่รู้ว่าใครจะใช้รหัสของคุณ (บุคคลที่สามผู้ร่วมงานด้วยตัวคุณเองในภายหลังเป็นต้น)

มีวิธีที่จะขยายต้นแบบอย่างปลอดภัย (แต่ไม่ใช่ในเบราว์เซอร์ทั้งหมด) และมีวิธีการใช้วัตถุที่สร้างขึ้นจากต้นแบบที่ขยายอย่างปลอดภัย แต่กฎที่ดีกว่าคือการปฏิบัติตามหลักการของความประหลาดใจอย่างน้อยและหลีกเลี่ยงการปฏิบัติเหล่านี้โดยสิ้นเชิง

หากคุณมีเวลาสักหน่อยให้ดูการพูดคุย JSConf 2011 ของ Andrew Dupont "ทุกอย่างได้รับอนุญาต: การขยายบิวด์อิน"เพื่อการอภิปรายที่ดีเกี่ยวกับหัวข้อนี้

แต่กลับไปที่คำถามในขณะที่วิธีการแก้ปัญหาข้างต้นจะทำงานได้พวกเขามีความซับซ้อนมากเกินไปและต้องการค่าใช้จ่ายในการคำนวณที่ไม่จำเป็น นี่คือทางออกของฉัน:

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;

ฉันทดสอบคำตอบต่าง ๆ ใน 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;
}

ฉันต้องการใช้วิธีการต่อรอย :

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

สายการบินเดียวใน 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))

คำถามเก่า: คำตอบใหม่! ที่จริงฉันทำงานกับคำตอบจากคำถามนี้และมีเพื่อนปรับปรุงมัน! ดังนั้นนี่คือ:

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]]

ทุกวันนี้คุณสามารถใช้ฟังก์ชั่นอันสั้นของ lodash เพื่อแบ่งอาร์เรย์ออกเป็นอาร์เรย์ขนาดเล็กลงhttps://lodash.com/docs#chunkไม่จำเป็นต้องเล่นกับวงอีกต่อไป!

มีคำตอบมากมาย แต่นี่คือสิ่งที่ฉันใช้:

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]]

ขั้นแรกให้ตรวจสอบส่วนที่เหลือเมื่อทำการหารดัชนีด้วยขนาดก้อน

หากมีเศษเหลืออยู่ให้ส่งคืนอาร์เรย์ตัวสะสม

หากไม่มีเศษเหลืออยู่ดัชนีจะถูกหารด้วยขนาดก้อนดังนั้นนำชิ้นส่วนจากอาร์เรย์เดิม (เริ่มต้นที่ดัชนีปัจจุบัน) และเพิ่มลงในอาร์เรย์ตัวสะสม

ดังนั้นอาร์เรย์แอคคิวมูเลเตอร์ที่ส่งคืนสำหรับการลดซ้ำแต่ละครั้งจะมีลักษณะดังนี้:

// 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]]

การใช้เครื่องกำเนิดไฟฟ้า

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]]

โอเคเรามาเริ่มกันดีกว่า:

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

จากนั้นเรามีฟังก์ชั่นลดแรงตึงตัวนี้:

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

ฉันมุ่งเป้าไปที่การสร้างโซลูชันที่ไม่กลายพันธุ์ง่าย ๆ ใน ES6 บริสุทธิ์ คุณลักษณะเฉพาะในจาวาสคริปต์ทำให้จำเป็นต้องกรอกข้อมูลในอาร์เรย์ที่ว่างเปล่าก่อนทำการแมป :-(

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 สร้างขึ้นเพื่อไขปริศนาที่ดี :-)

ฉันคิดว่านี่เป็นโซลูชันแบบเรียกซ้ำที่มีไวยากรณ์ 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));

สร้างแพคเกจ npm สำหรับhttps://www.npmjs.com/package/array.chunkนี้

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;

หากคุณใช้ EcmaScript เวอร์ชัน> = 5.1 คุณสามารถใช้เวอร์ชันการทำงานของการchunk()ใช้array.reduce ()ที่มีความซับซ้อน O (N):

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' ] ]

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 ] ]

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

วิธี 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)

และนี่จะเป็นผลงานของฉันในหัวข้อนี้ ฉันเดาว่า.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));

ใช้อันจาก Lodash

lodash.chunk(arr,<size>).forEach(chunk=>{
  console.log(chunk);
})

อีกวิธีใช้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มาก อย่างไรก็ตามเนื่องจากวิธีนี้ไม่ได้ใช้การแพร่กระจายของอาเรย์และไม่ได้สร้างอาร์เรย์ใหม่ในฟังก์ชั่นลดจึงเร็วกว่า (ดูการทดสอบ jsPerf ) และอ่านได้ง่ายกว่า (ไวยากรณ์ที่ง่ายกว่า) กว่าโซลูชันอื่น

ที่การวนซ้ำทุกครั้งที่n (โดยที่n = size; เริ่มต้นการทำซ้ำครั้งแรก) อาร์เรย์ตัวสะสม ( acc) จะถูกต่อท้ายด้วยชุดของแถว (arr.slice(i, i + size) ) แล้วส่งคืน ในการวนซ้ำอื่น ๆ อาร์เรย์ตัวสะสมจะถูกส่งกลับตามสภาพเดิม

ถ้าsizeเป็นศูนย์วิธีการส่งกลับอาร์เรย์ที่ว่างเปล่า ถ้าsizeเป็นลบเมธอดจะส่งคืนผลลัพธ์ที่เสียหาย ดังนั้นหากจำเป็นในกรณีของคุณคุณอาจต้องการทำอะไรบางอย่างเกี่ยวกับค่าลบหรือไม่ใช่sizeค่าบวก

หากความเร็วมีความสำคัญในกรณีของคุณการforวนรอบแบบง่ายจะเร็วกว่าการใช้arr.reduce()(ดูการทดสอบ jsPerf ) และบางคนอาจพบว่าสไตล์นี้อ่านง่ายขึ้นเช่นกัน:

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
}

สำหรับโซลูชันที่ใช้งานได้โดยใช้Ramda :

popularProductsอาร์เรย์อินพุตของคุณอยู่ที่ไหน5ขนาดก้อน

import splitEvery from 'ramda/src/splitEvery'

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

})

ES6 one-line approach ตามArray.prototype reduceและpushวิธีการ:

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]]

รุ่นเครื่องกำเนิด ES6

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

นี่เป็นโซลูชันที่มีประสิทธิภาพและตรงไปตรงมาที่สุดที่ฉันสามารถนึกได้:

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

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

ต่อไปนี้เป็นโซลูชันแบบเรียกซ้ำที่เหมาะสำหรับการโทรหาง

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

แก้ไข: @ 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เพื่อเปลี่ยนความยาวสูงสุดของอาร์เรย์ที่เล็กลง

นี่คือโซลูชันที่ไม่กลายพันธุ์โดยใช้การเรียกซ้ำและการแบ่งเท่านั้น ()

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/