Hướng dẫn split array into subarrays javascript - chia mảng thành các mảng con javascript

Question

Đã có nhiều câu trả lời nhưng đây là những gì tôi sử dụng:

Nội dung chính Show

Giới thiệu
Chia mảng thành các khối thậm chí bằng phương thức Slice ()
Chia mảng thành các khối thậm chí bằng phương thức splice ()
Sự kết luận
Làm thế nào để bạn chia một mảng trong JavaScript?
Làm thế nào để bạn chia một mảng thành hai phần?
Làm thế nào để bạn chia một mảng trong nút js?
Làm thế nào để bạn chia một mảng thành Subarrays?

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

Đầu tiên, hãy kiểm tra phần còn lại khi chia chỉ số cho kích thước chunk.

Nếu có một phần còn lại thì chỉ cần trả lại mảng tích lũy.

Nếu không có phần còn lại thì chỉ mục được chia chia cho kích thước chunk, vì vậy hãy lấy một lát từ mảng ban đầu (bắt đầu từ chỉ mục hiện tại) và thêm nó vào mảng tích lũy.

Vì vậy, mảng bộ tích lũy được trả lại cho mỗi lần lặp giảm bớt trông giống như thế này:

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

Giới thiệu

Mảng là một trong những cấu trúc được sử dụng nhiều nhất trong lập trình JavaScript, đó là lý do tại sao điều quan trọng là phải biết các phương pháp tích hợp của nó như mặt sau túi của bạn.

Trong hướng dẫn này, chúng ta sẽ xem cách chia một mảng thành các khối có kích thước n trong JavaScript.

Cụ thể, chúng ta sẽ xem xét hai cách tiếp cận:

Sử dụng phương thức slice() và vòng lặp for

Sử dụng phương thức

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

0 và vòng lặp

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

1

Chia mảng thành các khối thậm chí bằng phương thức Slice ()

Cách dễ nhất để trích xuất một đoạn của một mảng, hay đúng hơn là cắt nó lên, là phương pháp slice():

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

3 - Trả về một phần của mảng được gọi, giữa các chỉ số

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

4 và

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

5.

Lưu ý: Cả

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

4 và
// 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]]
5 có thể là số nguyên âm, chỉ biểu thị rằng chúng được liệt kê từ cuối mảng.
// 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]]
8 là yếu tố cuối cùng của mảng,
// 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]]
9 là người tiếp theo cuối cùng, v.v. Both

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

4 and

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

5 can be negative integers, which just denotes that they're enumerated from the end of the array.

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

8 being the last element of the array,

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

9 being the next to last and so on...

Mảng được trả về bởi slice() trả về một bản sao nông, có nghĩa là bất kỳ tài liệu tham khảo nào trong mảng gốc sẽ được sao chép qua AS-IS và sẽ không phân bổ bộ nhớ cho các đối tượng hoàn toàn mới.

Vì vậy, để cắt một danh sách hoặc mảng thành các khối, hãy sử dụng phương thức slice():

function sliceIntoChunks(arr, chunkSize) {
    const res = [];
    for (let i = 0; i < arr.length; i += chunkSize) {
        const chunk = arr.slice(i, i + chunkSize);
        res.push(chunk);
    }
    return res;
}

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(sliceIntoChunks(arr, 3));

Chạy mã trên mang lại đầu ra sau:

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

Trong mã trên, chúng tôi chia

function sliceIntoChunks(arr, chunkSize) {
    const res = [];
    for (let i = 0; i < arr.length; i += chunkSize) {
        const chunk = arr.slice(i, i + chunkSize);
        res.push(chunk);
    }
    return res;
}

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(sliceIntoChunks(arr, 3));

2 thành các khối nhỏ hơn có kích thước

function sliceIntoChunks(arr, chunkSize) {
    const res = [];
    for (let i = 0; i < arr.length; i += chunkSize) {
        const chunk = arr.slice(i, i + chunkSize);
        res.push(chunk);
    }
    return res;
}

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(sliceIntoChunks(arr, 3));

3, bằng cách lặp qua mảng và cắt nó mỗi

function sliceIntoChunks(arr, chunkSize) {
    const res = [];
    for (let i = 0; i < arr.length; i += chunkSize) {
        const chunk = arr.slice(i, i + chunkSize);
        res.push(chunk);
    }
    return res;
}

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(sliceIntoChunks(arr, 3));

4. Trong lần lặp cuối cùng, sẽ chỉ còn một yếu tố (

function sliceIntoChunks(arr, chunkSize) {
    const res = [];
    for (let i = 0; i < arr.length; i += chunkSize) {
        const chunk = arr.slice(i, i + chunkSize);
        res.push(chunk);
    }
    return res;
}

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(sliceIntoChunks(arr, 3));

5), sẽ phải tạo nên đoạn riêng của nó.

Chia mảng thành các khối thậm chí bằng phương thức splice ()

Mặc dù phương pháp

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

0 có vẻ giống với phương pháp slice(), việc sử dụng và tác dụng phụ của nó rất khác nhau. Hãy xem xét kỹ hơn:

// Splice does the following two things:
// 1. Removes deleteCount elements starting from startIdx (in-place)
// 2. Inserts the provided new elements (newElem1, newElem2...) into myArray starting with index startIdx (also in-place)
// The return value of this method is an array that contains all the deleted elements
myArray.splice(startIdx, deleteCount, newElem1, newElem2...)

let arrTest = [2, 3, 1, 4]
let chunk = arrTest.splice(0,2)
console.log(chunk) // [2, 3]
console.log(arrTest) // [1, 4]

Hãy xem điều này trong hành động thông qua một ví dụ về mã:

Kiểm tra hướng dẫn thực hành của chúng tôi, thực tế để học Git, với các thực hành tốt nhất, các tiêu chuẩn được công nghiệp chấp nhận và bao gồm bảng gian lận. Ngừng các lệnh git googling và thực sự tìm hiểu nó!

function spliceIntoChunks(arr, chunkSize) {
    const res = [];
    while (arr.length > 0) {
        const chunk = arr.splice(0, chunkSize);
        res.push(chunk);
    }
    return res;
}

const arr = [1, 2, 3, 4, 5, 6, 7, 8];
console.log(spliceIntoChunks(arr, 2));

Chạy mã này mang lại:

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

Ở đây chúng tôi đang sử dụng vòng lặp

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

1 để đi qua mảng. Trong mỗi lần lặp, chúng tôi thực hiện thao tác nối và đẩy mỗi khối vào một mảng kết quả cho đến khi không còn phần tử nào trong mảng gốc (

function sliceIntoChunks(arr, chunkSize) {
    const res = [];
    for (let i = 0; i < arr.length; i += chunkSize) {
        const chunk = arr.slice(i, i + chunkSize);
        res.push(chunk);
    }
    return res;
}

const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(sliceIntoChunks(arr, 3));

9).

Một điều rất quan trọng cần lưu ý là

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

0 thay đổi mảng ban đầu. Khi slice() tạo ra một bản sao của mảng gốc, do đó sẽ không có bất kỳ thay đổi nào trong bản gốc.

Sự kết luận

Trong bài viết này, chúng tôi đã xem qua một vài cách dễ dàng để chia một danh sách thành các phần thậm chí trong JavaScript. Trong khi làm như vậy, chúng tôi đã học cách làm việc với một vài phương pháp mảng tích hợp như slice() và

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

0.

Làm thế nào để bạn chia một mảng trong JavaScript?

Chia mảng thành các khối thậm chí bằng cách sử dụng phương pháp Slice () Cách dễ nhất để trích xuất một khối mảng, hay đúng hơn, để cắt nó lên, là phương thức Slice (): Mảng, giữa các chỉ số bắt đầu và kết thúc.slice() Method The easiest way to extract a chunk of an array, or rather, to slice it up, is the slice() method: slice(start, end) - Returns a part of the invoked array, between the start and end indices.

Làm thế nào để bạn chia một mảng thành hai phần?

Để chia một mảng thành hai, chúng ta cần ít nhất ba biến mảng.Chúng ta sẽ lấy một mảng với các số liên tục và sau đó lưu trữ các giá trị của nó thành hai biến khác nhau dựa trên các giá trị chẵn và lẻ.take an array with continuous numbers and then shall store the values of it into two different variables based on even and odd values.

Làm thế nào để bạn chia một mảng trong nút js?

Hàm chia () là một hàm chuỗi của nút.JS được sử dụng để chia chuỗi thành các chuỗi phụ.Hàm này trả về đầu ra ở dạng mảng.Tham số: Hàm này chấp nhận phân tách tham số đơn giữ ký tự để phân chia chuỗi. is a string function of Node. js which is used to split string into sub-strings. This function returns the output in array form. Parameters: This function accepts single parameter separator which holds the character to split the string.

Làm thế nào để bạn chia một mảng thành Subarrays?

Đưa ra một mảng mảng [] và một số nguyên k ...

Lấy tối đa từ Subarray đó ..

Trừ từng phần tử của subarray với mức tối đa ..

Lấy tổng của tất cả các giá trị sau khi trừ ..

programming javascript Split array JavaScript Slice Array JavaScript Array splice Copy array JavaScript Splice array JavaScript Sub array javascript Split array Python

Hướng dẫn split array into subarrays javascript - chia mảng thành các mảng con javascript

Giới thiệu

Chia mảng thành các khối thậm chí bằng phương thức Slice ()

Chia mảng thành các khối thậm chí bằng phương thức splice ()

Sự kết luận

Làm thế nào để bạn chia một mảng trong JavaScript?

Làm thế nào để bạn chia một mảng thành hai phần?

Làm thế nào để bạn chia một mảng trong nút js?

Làm thế nào để bạn chia một mảng thành Subarrays?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội