Cách chia mảng dài thành các mảng nhỏ hơn, với JavaScript

Question

Tôi có một mảng email (có thể chỉ là 1 email hoặc 100 email) và tôi cần gửi mảng với yêu cầu ajax (tôi biết làm thế nào để làm), nhưng tôi chỉ có thể gửi một mảng có 10 hoặc ít hơn e-mail trong đó. Vì vậy, nếu có một mảng ban đầu của 20 e-mail tôi sẽ cần phải chia chúng thành 2 mảng 10 mỗi. hoặc nếu có 15 e-mail trong mảng ban đầu, sau đó 1 mảng của 10, và một mảng khác của 5. Tôi đang sử dụng jQuery, những gì sẽ là cách tốt nhất để làm điều này?

Answer 1

không sử dụng jquery ... sử dụng đồng bằng javascript

var a = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]; 

var b = a.splice(0,10); 

//a is now [11,12,13,14,15]; 
//b is now [1,2,3,4,5,6,7,8,9,10]; 

Bạn có thể lặp lại thao tác này để có được hành vi bạn muốn.

var a = YOUR_ARRAY; 
while(a.length) { 
    console.log(a.splice(0,10)); 
} 

Điều này sẽ cung cấp cho bạn 10 thành phần cùng một lúc ... nếu bạn có 15 phần tử, bạn sẽ nhận được 1-10, mức 11-15 như bạn muốn.

Answer 2

var size = 10; 
for (var i=0; i<bigarray.length; i+=size) { 
    var smallarray = bigarray.slice(i,i+size); 
    // do something with smallarray 
} 

Không giống như splice(), slice() không phá hủy mảng ban đầu.

Answer 3

Chỉ cần lặp qua mảng, nối nó cho đến khi tất cả được tiêu thụ.

var a = ['a','b','c','d','e','f','g'] 
    , chunk 

while (a.length > 0) { 

    chunk = a.splice(0,3) 

    console.log(chunk) 

} 

đầu ra

[ 'a', 'b', 'c' ] 
[ 'd', 'e', 'f' ] 
[ 'g' ] 

Answer 4

Giả sử bạn không muốn để tiêu diệt các mảng ban đầu, bạn có thể sử dụng mã như thế này để phá vỡ các mảng dài vào mảng nhỏ mà sau đó bạn có thể duyệt qua:

var longArray = []; // assume this has 100 or more email addresses in it 
var shortArrays = [], i, len; 

for (i = 0, len = longArray.length; i < len; i += 10) { 
    shortArrays.push(longArray.slice(i, i + 10)); 
} 

// now you can iterate over shortArrays which is an 
// array of arrays where each array has 10 or fewer 
// of the original email addresses in it 

for (i = 0, len = shortArrays.length; i < len; i++) { 
    // shortArrays[i] is an array of email addresss of 10 or less 
} 

Answer 5

Là một bổ sung @ của answer jyore, và trong trường hợp bạn vẫn muốn giữ lại các mảng ban đầu:

var originalArray = [1,2,3,4,5,6,7,8]; 

var splitArray = function (arr, size) { 

    var arr2 = arr.slice(0), 
     arrays = []; 

    while (arr2.length > 0) { 
     arrays.push(arr2.splice(0, size)); 
    } 

    return arrays; 
} 

splitArray(originalArray, 2); 
// originalArray is still = [1,2,3,4,5,6,7,8]; 

Answer 6

Bạn có thể sử dụng lodash: https://lodash.com/docs

_.chunk(['a', 'b', 'c', 'd'], 2); 
// → [['a', 'b'], ['c', 'd']] 

Answer 7

Bạn có thể có một cái nhìn tại mã này. Đơn giản và hiệu quả.

function chunkArrayInGroups(array, unit) { 
var results = [], 
length = Math.ceil(array.length/unit); 

for (var i = 0; i < length; i++) { 
    results.push(array.slice(i * unit, (i + 1) * unit)); 
} 
return results; 
} 

chunkArrayInGroups(["a", "b", "c", "d"], 2); 

Answer 8

Nếu bạn muốn có một phương pháp mà không sửa đổi các mảng hiện có, hãy thử này:

let oldArray = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]; 
let newArray = []; 
let size = 3; // Size of chunks you are after 
let j = 0; // This helps us keep track of the child arrays 

for (var i = 0; i < oldArray.length; i++) { 
    if (i % size === 0) { 
    j++ 
    } 
    if(!newArray[j]) newArray[j] = []; 
    newArray[j].push(oldArray[i]) 
} 

Answer 9

Một thực hiện:

const arr = ["H", "o", "w", " ", "t", "o", " ", "s", "p", "l", "i", "t", " ", "a", " ", "l", "o", "n", "g", " ", "a", "r", "r", "a", "y", " ", "i", "n", "t", "o", " ", "s", "m", "a", "l", "l", "e", "r", " ", "a", "r", "r", "a", "y", "s", ",", " ", "w", "i", "t", "h", " ", "J", "a", "v", "a", "S", "c", "r", "i", "p", "t"]; 

const size = 3; 
const res = arr.reduce((acc, curr, i) => { 
    if (!(i % size) ) { // if index is 0 or can be divided by the `size`... 
    acc.push(arr.slice(i, i + size)); // ..push a chunk of the original array to the accumulator 
    } 
    return acc; 
}, []); 

// => [["H", "o", "w"], [" ", "t", "o"], [" ", "s", "p"], ["l", "i", "t"], [" ", "a", " "], ["l", "o", "n"], ["g", " ", "a"], ["r", "r", "a"], ["y", " ", "i"], ["n", "t", "o"], [" ", "s", "m"], ["a", "l", "l"], ["e", "r", " "], ["a", "r", "r"], ["a", "y", "s"], [",", " ", "w"], ["i", "t", "h"], [" ", "J", "a"], ["v", "a", "S"], ["c", "r", "i"], ["p", "t"]] 

NB - Điều này không sửa đổi các mảng ban đầu .

Hoặc, nếu bạn muốn có một chức năng, bất biến và khép kín phương pháp:

function splitBy(size, list) { 
    return list.reduce((acc, curr, i, self) => { 
    if (!(i % size) ) { 
     return [ 
      ...acc, 
      self.slice(i, i + size), 
     ]; 
    } 
    return acc; 
    }, []); 
} 

Answer 10

Phương pháp khác:

var longArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; 
var size = 2; 

var newArray = new Array(Math.ceil(longArray.length/size)).fill("") 
    .map(function() { return this.splice(0, size) }, longArray.slice()); 

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

này không ảnh hưởng đến các mảng ban đầu như một bản sao, được làm bằng slice, được chuyển vào đối số 'this' của bản đồ.

Answer 11

thi khác, sử dụng Array.reduce (Tôi nghĩ rằng đó là người duy nhất còn thiếu!):

const splitArray = (arr, size) => 
{ 
    if (size === 0) { 
     return []; 
    } 

    return arr.reduce((split, element, index) => { 
     index % size === 0 ? split.push([element]) : split[Math.floor(index/size)].push(element); 
     return split; 
    }, []); 
}; 

Như nhiều giải pháp trên, này không phá hủy một. Trả về một mảng trống khi kích thước bằng 0 chỉ là một quy ước. Nếu khối if bị bỏ qua, bạn sẽ gặp lỗi, có thể là lỗi bạn muốn.

Answer 12

Đây là một đơn giản lót

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); 
 
console.log(segment(arr,7));

Answer 13

Tôi muốn chia sẻ giải pháp của tôi là tốt. Đó là một chút chi tiết hơn nhưng hoạt động là tốt.

var data = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]; 

var chunksize = 4; 


var chunks = []; 

data.forEach((item)=>{ 
    if(!chunks.length || chunks[chunks.length-1].length == chunksize) 
    chunks.push([]); 

    chunks[chunks.length-1].push(item); 
}); 

console.log(chunks); 

Output (định dạng):

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

Answer 14

function chunkArrayInGroups(arr, size) { 
    var newArr=[]; 

    for (var i=0; arr.length>size; i++){ 
    newArr.push(arr.splice(0,size)); 
    } 
    newArr.push(arr.slice(0)); 
    return newArr; 

} 

chunkArrayInGroups([0, 1, 2, 3, 4, 5, 6], 3);