programming javascript

Có chức năng xáo trộn trong JavaScript không?

Xáo trộn một mảng là một câu hỏi phổ biến trong các cuộc phỏng vấn mã hóa. Có một số cách khác nhau để xáo trộn một mảng trong JavaScript

Bản đồ JavaScript[] - Giải thích

Vui lòng bật JavaScript

Bản đồ JavaScript[] - Giải thích

Xáo trộn một mảng có nghĩa là ngẫu nhiên hóa thứ tự của các mục bằng cách đặt chúng vào các vị trí khác nhau trong mảng. Theo cách này, các mục trong một mảng tự định vị lại bằng cách thay đổi chỉ mục của chúng

Bất cứ khi nào bạn muốn xáo trộn hoặc sắp xếp ngẫu nhiên một mảng, bạn phải tạo một chỉ mục ngẫu nhiên cho từng mục của mảng đó

Có các phương pháp sau bạn có thể sử dụng để trộn một mảng trong JavaScript

Thuật toán xáo trộn Fisher-Yates trong JavaScript

Áp dụng phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

2 để ngẫu nhiên hóa một mảng trong JavaScript

Sử dụng

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

3 với phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

2 để lấy một mảng được xáo trộn

Trong bài viết này, tôi sẽ hướng dẫn bạn các phương pháp khác nhau để xáo trộn hoặc ngẫu nhiên hóa một mảng JavaScript từng bước cùng với ưu và nhược điểm của chúng

Cũng đọc. Cách xóa phần tử khỏi mảng trong JavaScript

Xáo trộn một mảng JavaScript bằng thuật toán Fisher-Yates

Trong số các phương pháp khác nhau, thuật toán xáo trộn Fisher-Yates tốt hơn về hiệu suất và độ tin cậy. Thuật toán này sắp xếp lại một mảng theo thứ tự ngẫu nhiên hơn

Đây là một thuật toán đơn giản lặp qua mảng theo thứ tự ngược lại và hoán đổi từng phần tử với một phần tử ngẫu nhiên trong mảng. Bạn có thể làm điều này chỉ trong 4 bước

Lặp lại mảng để chọn từng phần tử

Tạo chỉ mục ngẫu nhiên bằng phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Lưu trữ giá trị của mục mảng hiện tại trong một biến mới
Hoán đổi mục mảng hiện tại với mục được tạo ngẫu nhiên

Hãy xem chi tiết từng bước với một ví dụ

Bước 1. Trong ví dụ này, tôi đã tạo một hàm có tên là

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

6 chấp nhận một mảng làm đối số của nó. Bên trong hàm, tôi đang lặp qua mảng bằng vòng lặp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        // step 2
        // step 3
        // step 4
    }
};

Vòng lặp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

7 này sẽ đi qua tất cả các mục theo thứ tự ngược lại

Bước 2. Tôi đang tạo một chỉ mục ngẫu nhiên nằm trong khoảng từ 0 đến

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

9 [chỉ mục mục hiện tại]. Tôi đang lưu trữ chỉ số ngẫu nhiên đó trong biến

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        
        // Swap
        array[i] = array[j];
        array[j] = temp;
    }
    return array;
};

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Bước 3. Tôi đang lưu trữ mục hiện tại trong biến

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        
        // Swap
        array[i] = array[j];
        array[j] = temp;
    }
    return array;
};

1 bằng cách sử dụng

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        
        // Swap
        array[i] = array[j];
        array[j] = temp;
    }
    return array;
};

2 để hoán đổi mục đó với mục ngẫu nhiên

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Bước 4. Cuối cùng, tôi hoán đổi các mục

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        
        // Swap
        array[i] = array[j];
        array[j] = temp;
    }
    return array;
};

2 và

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        
        // Swap
        array[i] = array[j];
        array[j] = temp;
    }
    return array;
};

4 với nhau. Đặt mục được tạo ngẫu nhiên tại chỉ mục

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

9 và đặt mục hiện tại vào vòng lặp tại chỉ mục

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        
        // Swap
        array[i] = array[j];
        array[j] = temp;
    }
    return array;
};

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        
        // Swap
        array[i] = array[j];
        array[j] = temp;
    }
    return array;
};

Sau khi hoàn thành tất cả các bước này, tôi sẽ trả về mảng đã xáo trộn từ hàm sau khi hoàn thành vòng lặp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Bây giờ bạn có thể sử dụng chức năng này để trộn bất kỳ loại mảng JavaScript nào

Tôi đã tạo một dãy số. Nó không nhất thiết phải là một mảng số. Bạn cũng có thể sử dụng chuỗi hoặc đối tượng

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Khi tôi truyền mảng vào hàm

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

6, nó sẽ trả về một mảng đã xáo trộn

Cũng đọc. Hàm xây dựng JavaScript được giải thích bằng các ví dụ

Viết thuật toán Fisher-Yates với cú pháp JavaScript ES6

Bạn có thể triển khai thuật toán xáo trộn

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        
        // Swap
        array[i] = array[j];
        array[j] = temp;
    }
    return array;
};

9 bằng cú pháp JavaScript ES6 nếu muốn mà không cần sử dụng vòng lặp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Trong ví dụ này, tôi đang sử dụng cú pháp ES6. Với phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

01, tôi đang đảo ngược mảng. Sau đó, tôi lặp lại mảng bị đảo ngược bằng phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Bên trong hàm gọi lại, chúng tôi tự động lấy mục mảng hiện tại và chỉ mục của nó. Vì vậy, bạn chỉ cần tạo một chỉ mục ngẫu nhiên để chọn một mục khác từ mảng

Sau khi chọn ngẫu nhiên mục thứ hai, bạn có thể hoán đổi chúng bằng toán tử trải rộng mảng trong JavaScript

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Khi bạn gọi hàm

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

03 với một mảng, nó cũng sẽ trả về một mảng đã xáo trộn. Bây giờ, bạn muốn sử dụng cú pháp nào trong ứng dụng của mình tùy thuộc vào bạn

Xáo trộn một mảng JavaScript bằng phương thức sort[]

Nếu bạn muốn có một cách đơn giản để sắp xếp lại mảng JavaScript của mình mà không cần sử dụng thuật toán Fisher-Yates, bạn có thể sử dụng phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

04 mảng JavaScript tích hợp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Tôi cũng đang tạo một hàm

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

6 chấp nhận một mảng trong đối số của nó. Tôi sẽ áp dụng phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

06 cho mảng này để ngẫu nhiên hóa nó

Phương pháp này có một chức năng gọi lại. Và bạn phải trả về số dương hoặc số âm từ hàm gọi lại đó

Phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

06 hoán đổi một mục với mục tiếp theo trong một mảng tùy thuộc vào giá trị được trả về từ hàm gọi lại của nó

Để trả về một số, tôi đang tạo một số ngẫu nhiên trong khoảng từ 0 đến 1 bằng phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Sau đó, tôi trừ số ngẫu nhiên đó từ 0. 5 và trả về từ chức năng gọi lại. Bằng cách này, bạn có thể tạo ngẫu nhiên một số dương hoặc số âm mỗi lần

Nếu phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

5 tạo ra một số lớn hơn 0. 5 thì hàm gọi lại sẽ trả về số âm. Nếu nó tạo ra một số nhỏ hơn 0. 5 thì hàm gọi lại sẽ trả về một số dương

Ví dụ: nếu phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

5 cho 0. 75 và sau khi trừ nó từ 0. 5 bạn sẽ nhận được -0. 25 là số âm

Mặt khác, nếu phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

5 cho 0. 3 và sau khi trừ nếu từ 0. 5 bạn sẽ nhận được 0. 2 là số dương

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Thuật toán Fisher-Yates VS Mảng. phương pháp sắp xếp []

Ngay cả khi cả hai phương pháp đều có thể xáo trộn một mảng trong JavaScript, thì thuật toán Fisher-Yates có thể trộn một mảng hiệu quả hơn so với phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Vì phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

2 chỉ hoán đổi 2 phần tử cạnh nhau trong một mảng. Mặt khác, thuật toán Fisher-Yates có thể hoán đổi một phần tử với bất kỳ phần tử nào khác trong mảng

Đó là lý do tại sao thuật toán này có thể trả về một mảng được xáo trộn nhiều hơn so với phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

2 trong JavaScript

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Sau khi chạy cả hai phương pháp một vài lần, chúng ta có thể thấy sự khác biệt. Thuật toán Fisher-Yates đang trả về một mảng được xáo trộn nhiều hơn mỗi lần

Nếu bạn muốn một cách đơn giản để sắp xếp lại mảng JavaScript của mình và bạn không cần một mảng bị xáo trộn nhiều hơn thì bạn có thể sử dụng phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

06 hoặc

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Nhưng nếu bạn cần một mảng ngẫu nhiên hơn mỗi lần thì hãy sử dụng thuật toán xáo trộn Fisher-Yates để trộn mảng JavaScript của bạn

Cũng đọc. Hướng dẫn tốt nhất về Nhập động trong JavaScript để nhập mô-đun

Xáo trộn một mảng trong JavaScript mà không thay đổi mảng ban đầu

Nếu chúng ta xem xét cả hai phương pháp được trình bày trong các phần trước cho thuật toán Fisher-Yates và phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

47], bạn sẽ thấy cả hai đều sửa đổi mảng ban đầu

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Trong ví dụ này, chúng ta có thể thấy nếu chúng ta gọi phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

03, nó sẽ trả về một mảng được xáo trộn. Nhưng sau đó, nó cũng thay đổi mảng ban đầu

Điều tương tự cũng xảy ra với phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

2. Nếu bạn không muốn hành vi này, bạn có thể dễ dàng thay đổi nó chỉ bằng cách thêm một dòng mã

Dung dịch

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Để giữ nguyên mảng ban đầu, bạn phải tạo một bản sao mới của mảng bằng cách sử dụng toán tử trải rộng trong JavaScript

Bên trong hàm

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

03, tôi đang tạo một bản sao của mảng ban đầu và lưu trữ nó trong biến

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Thay vì sử dụng mảng ban đầu, bạn phải sử dụng mảng đã sao chép để xáo trộn. Cuối cùng, bạn sẽ trả về mảng đã sao chép từ hàm

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Bạn có thể làm tương tự với phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

2. Lần này nó sẽ trả về một mảng đã xáo trộn mà không sửa đổi mảng ban đầu

Xáo trộn một mảng trong JavaScript với phương thức map[]

Bạn có thể chọn ngẫu nhiên một mảng JavaScript bằng phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

46. Trong kỹ thuật này, chúng ta cần sử dụng đồng thời cả hai phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

46 và

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Hãy xem nó được thực hiện như thế nào

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Cần có tổng cộng 3 bước để hoàn tất quy trình này. Các bước này là

1. Tạo một mảng các đối tượng. Phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

46 đầu tiên sẽ lặp qua mảng và sẽ trả về một mảng đối tượng mới. Bên trong mảng này, mỗi đối tượng sẽ có 2 thuộc tính là

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

77 và

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Thuộc tính

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

77 chứa một số ngẫu nhiên trong khoảng từ 0 đến 1 được tạo bởi phương pháp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

5. Thuộc tính

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

78 chứa mục thực tế từ mảng ban đầu

2. Xáo trộn mảng các đối tượng. Phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

06 sẽ xáo trộn mảng các đối tượng được tạo bởi phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

46 trước đó theo giá trị được trả về từ hàm gọi lại

Nó sẽ trả về giá trị dương hoặc âm bằng cách trừ 2 thuộc tính

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

77 khỏi 2 đối tượng. Vì số trong thuộc tính sắp xếp được tạo ngẫu nhiên, phép trừ cũng sẽ trả về số dương hoặc số âm một cách ngẫu nhiên

3. Lấy mảng ban đầu từ mảng đối tượng. Phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

46 thứ hai sẽ lặp qua mảng đối tượng đã xáo trộn và sẽ trả về một mảng mới với các thuộc tính giá trị. Nó sẽ xóa thuộc tính

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Do đó, mảng mới sẽ chỉ chứa các phần tử của mảng ban đầu nhưng theo thứ tự ngẫu nhiên

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Khi tôi gọi hàm

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

6 với một mảng, nó sẽ trả về một mảng được xáo trộn. Nhưng nếu bạn để ý, mảng ban đầu không thay đổi lần này

Vì phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

46 luôn trả về một mảng mới. Khi phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

46 đầu tiên được gọi, nó trả về một mảng mới và sau đó phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

06 xáo trộn mảng mới đó, không phải mảng ban đầu

Do đó, kỹ thuật này theo mặc định không sửa đổi mảng ban đầu

Cũng đọc. Đầu vào VS Thay đổi VS Làm mờ VS Tiêu điểm - Sự khác biệt của Sự kiện JavaScript

Cách xáo trộn một mảng các đối tượng trong JavaScript

Tất cả các kỹ thuật mà tôi đã trình bày trước đây sẽ xáo trộn bất kỳ loại mảng JavaScript nào. Mảng có thể chứa số, chuỗi, đối tượng hoặc bất kỳ loại nào khác. không quan trọng

Vì vậy, bạn không cần phải làm bất cứ điều gì để xáo trộn một mảng các đối tượng. Truyền một mảng đối tượng cho các hàm đó và chúng sẽ xáo trộn mảng của bạn

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

đầu ra

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Trong ví dụ này, tôi đang sử dụng thuật toán Fisher-Yates. Nhưng các phương thức

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

2 và

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

3 cũng sẽ xáo trộn các đối tượng mảng

Xáo trộn một mảng JavaScript với một thư viện bên ngoài

Bạn có thể sử dụng thư viện NPM bên ngoài như Lo-Dash để xáo trộn một mảng. Thư viện này có chức năng sẽ ngẫu nhiên hóa trực tiếp mảng của bạn mà không cần viết bất kỳ thuật toán nào

Chạy lệnh sau để khởi tạo một Node. dự án js

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Nó sẽ tạo một tệp

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

83 trong thư mục gốc của thư mục dự án của bạn. Tệp này sẽ liệt kê tất cả các gói đã cài đặt trong dự án của bạn

Cũng đọc. Thiết lập tốt nhất để sử dụng TypeScript với nút. js và Dự án Express

Bây giờ, hãy cài đặt thư viện

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

84 bằng lệnh sau

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Thư viện này cung cấp hàm

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

6 để xáo trộn một mảng trong JavaScript. Bạn chỉ cần nhập và gọi nó bằng một mảng

Chức năng này sử dụng thuật toán xáo trộn Fisher-Yates dưới mui xe

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Hàm này không sửa đổi mảng ban đầu. Nó cũng có thể xáo trộn một mảng các đối tượng

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

đầu ra

          const shuffle = [array] => {
    for [let i = array.length - 1; i > 0; i--] {
        const j = Math.floor[Math.random[] * [i + 1]];
        const temp = array[i];
        // step 4
    }
};

Sự kết luận

Có nhiều cách để xáo trộn một mảng JavaScript. Chỉ vì mục đích này mà cài đặt một thư viện không phải là một ý tưởng hay. Bởi vì các thư viện bên ngoài như Lo-Dash chứa rất nhiều chức năng

Vì vậy, kích thước của chúng cũng trở nên lớn. Nếu bạn cần các tính năng khác mà các thư viện này cung cấp thì bạn nên sử dụng chúng. Vì nó sẽ giúp bạn tiết kiệm rất nhiều thời gian

Mặt khác, bạn có thể viết hàm của riêng mình một cách dễ dàng để ngẫu nhiên hóa mảng của bạn. Bằng cách này, ứng dụng của bạn sẽ có ít mã không cần thiết hơn

Xáo trộn trong JavaScript là gì?

Viết hàm xáo trộn[mảng] xáo trộn [ sắp xếp lại ngẫu nhiên] các phần tử của mảng . Nhiều lần xáo trộn có thể dẫn đến các thứ tự khác nhau của các phần tử. Ví dụ. hãy mảng = [1, 2, 3]; .

Làm cách nào để xáo trộn các mục trong JavaScript?

Các phần tử mảng JavaScript có thể được xáo trộn bằng cách sử dụng phương thức sort[] . Phương thức Array sort[] của JavaScript được sử dụng để sắp xếp các phần tử của một mảng. Phương thức chấp nhận một hàm so sánh và thực hiện sắp xếp dựa trên giá trị được trả về bởi hàm đó.

Làm cách nào để xáo trộn một chuỗi trong js?

Làm cách nào để trộn văn bản trong Javascript? .

Sợi dây. nguyên mẫu. xáo trộn = hàm [] {

var a = cái này. tách ra[""],

n = một. chiều dài;

for[var i = n – 1; i > 0; i–] {

var j = Toán học. tầng [Toán. ngẫu nhiên[] * [i + 1]];

var tmp = a[i];

a[i] = a[j];