Tôi đang làm việc về 'cách truy cập các phần tử một cách ngẫu nhiên từ một mảng trong javascript'. Tôi tìm thấy nhiều liên kết liên quan đến điều này. Như: Nhận mục ngẫu nhiên từ mảng JavaScript

var item = items[Math.floor(Math.random()*items.length)];

Nhưng trong điều này, chúng ta chỉ có thể chọn một mục từ mảng. Nếu chúng ta muốn có nhiều hơn một yếu tố thì làm thế nào chúng ta có thể đạt được điều này? Làm cách nào chúng ta có thể lấy nhiều hơn một phần tử từ một mảng?

Hãy thử chức năng không phá hủy (và nhanh ) này:

function getRandom(arr, n) {
    var result = new Array(n),
        len = arr.length,
        taken = new Array(len);
    if (n > len)
        throw new RangeError("getRandom: more elements taken than available");
    while (n--) {
        var x = Math.floor(Math.random() * len);
        result[n] = arr[x in taken ? taken[x] : x];
        taken[x] = --len in taken ? taken[len] : len;
    }
    return result;
}

Chỉ hai dòng:

// Shuffle array
const shuffled = array.sort(() => 0.5 - Math.random());

// Get sub-array of first n elements after shuffled
let selected = shuffled.slice(0, n);

DEMO :

Có một giải pháp duy nhất một lớp lót ở đây

 array.sort(() => Math.random() - Math.random()).slice(0, n)

Chuyển .sampletừ thư viện chuẩn Python:

function sample(population, k){
    /*
        Chooses k unique random elements from a population sequence or set.

        Returns a new list containing elements from the population while
        leaving the original population unchanged.  The resulting list is
        in selection order so that all sub-slices will also be valid random
        samples.  This allows raffle winners (the sample) to be partitioned
        into grand prize and second place winners (the subslices).

        Members of the population need not be hashable or unique.  If the
        population contains repeats, then each occurrence is a possible
        selection in the sample.

        To choose a sample in a range of integers, use range as an argument.
        This is especially fast and space efficient for sampling from a
        large population:   sample(range(10000000), 60)

        Sampling without replacement entails tracking either potential
        selections (the pool) in a list or previous selections in a set.

        When the number of selections is small compared to the
        population, then tracking selections is efficient, requiring
        only a small set and an occasional reselection.  For
        a larger number of selections, the pool tracking method is
        preferred since the list takes less space than the
        set and it doesn't suffer from frequent reselections.
    */

    if(!Array.isArray(population))
        throw new TypeError("Population must be an array.");
    var n = population.length;
    if(k < 0 || k > n)
        throw new RangeError("Sample larger than population or is negative");

    var result = new Array(k);
    var setsize = 21;   // size of a small set minus size of an empty list

    if(k > 5)
        setsize += Math.pow(4, Math.ceil(Math.log(k * 3, 4)))

    if(n <= setsize){
        // An n-length list is smaller than a k-length set
        var pool = population.slice();
        for(var i = 0; i < k; i++){          // invariant:  non-selected at [0,n-i)
            var j = Math.random() * (n - i) | 0;
            result[i] = pool[j];
            pool[j] = pool[n - i - 1];       // move non-selected item into vacancy
        }
    }else{
        var selected = new Set();
        for(var i = 0; i < k; i++){
            var j = Math.random() * n | 0;
            while(selected.has(j)){
                j = Math.random() * n | 0;
            }
            selected.add(j);
            result[i] = population[j];
        }
    }

    return result;
}

Triển khai được chuyển từ Lib / random.py .

Ghi chú:

• setsizeđược đặt dựa trên các đặc điểm trong Python để mang lại hiệu quả. Mặc dù nó chưa được điều chỉnh cho JavaScript, thuật toán vẫn sẽ hoạt động như mong đợi.
• Một số câu trả lời khác được mô tả trong trang này không an toàn theo đặc điểm kỹ thuật ECMAScript do việc sử dụng sai Array.prototype.sort. Tuy nhiên, thuật toán này được đảm bảo kết thúc trong thời gian hữu hạn.
• Đối với các trình duyệt cũ hơn chưa được Settriển khai, tập hợp có thể được thay thế bằng một Arrayvà .has(j)thay thế bằng .indexOf(j) > -1.

Hiệu suất so với câu trả lời được chấp nhận:

• 
• https://jsperf.com/pick-random-elements-from-an-array
• Sự khác biệt về hiệu suất là lớn nhất trên Safari.

Nhận 5 mục ngẫu nhiên mà không thay đổi mảng ban đầu:

const n = 5;
const sample = items
  .map(x => ({ x, r: Math.random() }))
  .sort((a, b) => a.r - b.r)
  .map(a => a.x)
  .slice(0, n);

(Không sử dụng cái này cho các danh sách lớn)

tạo một funcion để thực hiện điều đó:

var getMeRandomElements = function(sourceArray, neededElements) {
    var result = [];
    for (var i = 0; i < neededElements; i++) {
        result.push(sourceArray[Math.floor(Math.random()*sourceArray.length)]);
    }
    return result;
}

bạn cũng nên kiểm tra xem sourceArray có đủ các phần tử để trả về hay không. và nếu bạn muốn các phần tử duy nhất được trả về, bạn nên xóa phần tử đã chọn khỏi sourceArray.

Cú pháp ES6

const pickRandom = (arr,count) => {
  let _arr = [...arr];
  return[...Array(count)].map( ()=> _arr.splice(Math.floor(Math.random() * _arr.length), 1)[0] ); 
}

Nếu bạn muốn lấy ngẫu nhiên các mục từ mảng trong một vòng lặp mà không lặp lại, bạn có thể xóa mục đã chọn khỏi mảng bằng splice:

var items = [1, 2, 3, 4, 5];
var newItems = [];

for (var i = 0; i < 3; i++) {
  var idx = Math.floor(Math.random() * items.length);
  newItems.push(items[idx]);
  items.splice(idx, 1);
}

console.log(newItems);

Array.prototype.getnkill = function() {
    var a = Math.floor(Math.random()*this.length);
    var dead = this[a];
    this.splice(a,1);
    return dead;
}

//.getnkill() removes element in the array 
//so if you like you can keep a copy of the array first:

//var original= items.slice(0); 


var item = items.getnkill();

var anotheritem = items.getnkill();

Đây là một phiên bản được đánh máy độc đáo. Nó không thất bại. Trả về mảng xáo trộn nếu kích thước mẫu lớn hơn độ dài của mảng ban đầu.

function sampleArr<T>(arr: T[], size: number): T[] {
  const setOfIndexes = new Set<number>();
  while (setOfIndexes.size < size && setOfIndexes.size < arr.length) {
    setOfIndexes.add(randomIntFromInterval(0, arr.length - 1));
  }
  return Array.from(setOfIndexes.values()).map(i => arr[i]);
}

const randomIntFromInterval = (min: number, max: number): number =>
  Math.floor(Math.random() * (max - min + 1) + min);

lodash ( https://lodash.com/ ) _.samplevà _.sampleSize.

Nhận một hoặc n phần tử ngẫu nhiên tại các khóa duy nhất từ ​​bộ sưu tập cho đến kích thước của bộ sưu tập.

_.sample([1, 2, 3, 4]);
// => 2

_.sampleSize([1, 2, 3], 2);
// => [3, 1]
 
_.sampleSize([1, 2, 3], 4);
// => [2, 3, 1]

CHỈNH SỬA : Giải pháp này chậm hơn các giải pháp khác được trình bày ở đây (nối mảng nguồn) nếu bạn chỉ muốn lấy một vài phần tử. Tốc độ của giải pháp này chỉ phụ thuộc vào số phần tử trong mảng ban đầu, trong khi tốc độ của giải pháp nối phụ thuộc vào số lượng phần tử được yêu cầu trong mảng đầu ra.

Nếu bạn muốn các phần tử ngẫu nhiên không lặp lại, bạn có thể xáo trộn mảng của mình, sau đó chỉ lấy bao nhiêu tùy thích:

function shuffle(array) {
    var counter = array.length, temp, index;

    // While there are elements in the array
    while (counter--) {
        // Pick a random index
        index = (Math.random() * counter) | 0;

        // And swap the last element with it
        temp = array[counter];
        array[counter] = array[index];
        array[index] = temp;
    }

    return array;
}

var arr = [0,1,2,3,4,5,7,8,9];

var randoms = shuffle(arr.slice(0)); // array is cloned so it won't be destroyed
randoms.length = 4; // get 4 random elements

DEMO: http://jsbin.com/UHUHuqi/1/edit

Chức năng xáo trộn lấy từ đây: https://stackoverflow.com/a/6274398/1669279

Tôi cần một chức năng để giải quyết loại vấn đề này nên tôi đang chia sẻ nó ở đây.

    const getRandomItem = function(arr) {
        return arr[Math.floor(Math.random() * arr.length)];
    }

    // original array
    let arr = [4, 3, 1, 6, 9, 8, 5];

    // number of random elements to get from arr
    let n = 4;

    let count = 0;
    // new array to push random item in
    let randomItems = []
    do {
        let item = getRandomItem(arr);
        randomItems.push(item);
        // update the original array and remove the recently pushed item
        arr.splice(arr.indexOf(item), 1);
        count++;
    } while(count < n);

    console.log(randomItems);
    console.log(arr);

Lưu ý: nếu n = arr.lengthsau đó về cơ bản bạn đang xáo trộn mảng arrvà randomItemstrả về mảng đã xáo trộn đó.

Bản giới thiệu

Trong câu trả lời này, tôi muốn chia sẻ với bạn bài kiểm tra rằng tôi phải biết phương pháp tốt nhất mang lại cơ hội như nhau cho tất cả các phần tử có một mảng con ngẫu nhiên.

Phương pháp 01

array.sort(() => Math.random() - Math.random()).slice(0, n)

sử dụng phương pháp này, một số yếu tố có cơ hội cao hơn so với những yếu tố khác.

calculateProbability = function(number=0 ,iterations=10000,arraySize=100) { 
let occ = 0 
for (let index = 0; index < iterations; index++) {
   const myArray= Array.from(Array(arraySize).keys()) //=> [0, 1, 2, 3, 4, ... arraySize]
   
  /** Wrong Method */
    const arr = myArray.sort(function() {
     return val= .5 - Math.random();
      });
     
  if(arr[0]===number) {
    occ ++
    }

    
}

console.log("Probability of ",number, " = ",occ*100 /iterations,"%")

}

calculateProbability(0)
calculateProbability(0)
calculateProbability(0)
calculateProbability(50)
calculateProbability(50)
calculateProbability(50)
calculateProbability(25)
calculateProbability(25)
calculateProbability(25)

Phương pháp 2

Sử dụng phương pháp này, các phần tử có cùng xác suất:

 const arr = myArray
      .map((a) => ({sort: Math.random(), value: a}))
      .sort((a, b) => a.sort - b.sort)
      .map((a) => a.value)

calculateProbability = function(number=0 ,iterations=10000,arraySize=100) { 
let occ = 0 
for (let index = 0; index < iterations; index++) {
   const myArray= Array.from(Array(arraySize).keys()) //=> [0, 1, 2, 3, 4, ... arraySize]
   

  /** Correct Method */
  const arr = myArray
  .map((a) => ({sort: Math.random(), value: a}))
  .sort((a, b) => a.sort - b.sort)
  .map((a) => a.value)
    
  if(arr[0]===number) {
    occ ++
    }

    
}

console.log("Probability of ",number, " = ",occ*100 /iterations,"%")

}

calculateProbability(0)
calculateProbability(0)
calculateProbability(0)
calculateProbability(50)
calculateProbability(50)
calculateProbability(50)
calculateProbability(25)
calculateProbability(25)
calculateProbability(25)

Câu trả lời chính xác được đăng trong liên kết sau: https://stackoverflow.com/a/46545530/3811640

Đây là phiên bản được tối ưu hóa của mã được @Derek chuyển từ Python, với tùy chọn phá hủy (tại chỗ) được bổ sung giúp nó trở thành thuật toán nhanh nhất có thể nếu bạn có thể sử dụng nó. Nếu không, nó sẽ tạo một bản sao đầy đủ hoặc đối với một số lượng nhỏ các mục được yêu cầu từ một mảng lớn, sẽ chuyển sang thuật toán dựa trên lựa chọn.

// Chooses k unique random elements from pool.
function sample(pool, k, destructive) {
    var n = pool.length;

    if (k < 0 || k > n)
        throw new RangeError("Sample larger than population or is negative");

    if (destructive || n <= (k <= 5 ? 21 : 21 + Math.pow(4, Math.ceil(Math.log(k*3, 4))))) {
        if (!destructive)
            pool = Array.prototype.slice.call(pool);
        for (var i = 0; i < k; i++) { // invariant: non-selected at [i,n)
            var j = i + Math.random() * (n - i) | 0;
            var x = pool[i];
            pool[i] = pool[j];
            pool[j] = x;
        }
        pool.length = k; // truncate
        return pool;
    } else {
        var selected = new Set();
        while (selected.add(Math.random() * n | 0).size < k) {}
        return Array.prototype.map.call(selected, i => population[i]);
    }
}

So với cách triển khai của Derek, thuật toán đầu tiên nhanh hơn nhiều trong Firefox trong khi chậm hơn một chút trong Chrome, mặc dù bây giờ nó có tùy chọn hủy diệt - thuật toán hiệu quả nhất. Thuật toán thứ hai chỉ đơn giản là nhanh hơn 5-15%. Tôi cố gắng không đưa ra bất kỳ con số cụ thể nào vì chúng khác nhau tùy thuộc vào k và n và có lẽ sẽ không có ý nghĩa gì trong tương lai với các phiên bản trình duyệt mới.

Heuristic tạo ra sự lựa chọn giữa các thuật toán bắt nguồn từ mã Python. Tôi đã để nguyên như vậy, mặc dù đôi khi nó chọn cái chậm hơn. Nó nên được tối ưu hóa cho JS, nhưng đó là một nhiệm vụ phức tạp vì hiệu suất của các trường hợp góc phụ thuộc vào trình duyệt và phiên bản của chúng. Ví dụ: khi bạn cố gắng chọn 20 trong số 1000 hoặc 1050, nó sẽ chuyển sang thuật toán thứ nhất hoặc thứ hai cho phù hợp. Trong trường hợp này, cái đầu tiên chạy nhanh hơn 2 lần so với cái thứ hai trong Chrome 80 nhưng chậm hơn 3 lần trong Firefox 74.

2020
phong cách lập trình chức năng không phá hủy, làm việc trong một bối cảnh bất biến.

const _randomslice = (ar, size) => {
  let new_ar = [...ar];
  new_ar.splice(Math.floor(Math.random()*ar.length),1);
  return ar.length <= (size+1) ? new_ar : _randomslice(new_ar, size);
}


console.log(_randomslice([1,2,3,4,5],2));

Nó trích xuất từng phần tử ngẫu nhiên từ srcArray khi nó đã đủ hoặc không còn phần tử nào trong srcArray còn lại để giải nén. Nhanh chóng và đáng tin cậy.

function getNRandomValuesFromArray(srcArr, n) {
    // making copy to do not affect original srcArray
    srcArr = srcArr.slice();
    resultArr = [];
    // while srcArray isn't empty AND we didn't enough random elements
    while (srcArr.length && resultArr.length < n) {
        // remove one element from random position and add this element to the result array
        resultArr = resultArr.concat( // merge arrays
            srcArr.splice( // extract one random element
                Math.floor(Math.random() * srcArr.length),
                1
            )
        );
    }

    return resultArr;
}

2019

Điều này giống như câu trả lời của Laurynas Mališauskas , chỉ là các phần tử là duy nhất (không trùng lặp).

var getMeRandomElements = function(sourceArray, neededElements) {
    var result = [];
    for (var i = 0; i < neededElements; i++) {
    var index = Math.floor(Math.random() * sourceArray.length);
        result.push(sourceArray[index]);
        sourceArray.splice(index, 1);
    }
    return result;
}

Bây giờ để trả lời câu hỏi ban đầu "Làm thế nào để lấy nhiều phần tử ngẫu nhiên bằng jQuery", bạn vào đây:

var getMeRandomElements = function(sourceArray, neededElements) {
    var result = [];
    for (var i = 0; i < neededElements; i++) {
    var index = Math.floor(Math.random() * sourceArray.length);
        result.push(sourceArray[index]);
        sourceArray.splice(index, 1);
    }
    return result;
}

var $set = $('.someClass');// <<<<< change this please

var allIndexes = [];
for(var i = 0; i < $set.length; ++i) {
    allIndexes.push(i);
}

var totalRandom = 4;// <<<<< change this please
var randomIndexes = getMeRandomElements(allIndexes, totalRandom);

var $randomElements = null;
for(var i = 0; i < randomIndexes.length; ++i) {
    var randomIndex = randomIndexes[i];
    if($randomElements === null) {
        $randomElements = $set.eq(randomIndex);
    } else {
        $randomElements.add($set.eq(randomIndex));
    }
}

// $randomElements is ready
$randomElements.css('backgroundColor', 'red');

Đây là một hàm tôi sử dụng cho phép bạn dễ dàng lấy mẫu một mảng có hoặc không có thay thế:

  // Returns a random sample (either with or without replacement) from an array
  const randomSample = (arr, k, withReplacement = false) => {
    let sample;
    if (withReplacement === true) {  // sample with replacement
      sample = Array.from({length: k}, () => arr[Math.floor(Math.random() *  arr.length)]);
    } else { // sample without replacement
      if (k > arr.length) {
        throw new RangeError('Sample size must be less than or equal to array length         when sampling without replacement.')
      }
      sample = arr.map(a => [a, Math.random()]).sort((a, b) => {
        return a[1] < b[1] ? -1 : 1;}).slice(0, k).map(a => a[0]); 
      };
    return sample;
  };

Sử dụng nó rất đơn giản:

Không có thay thế (hành vi mặc định)

randomSample([1, 2, 3], 2) có thể trở lại [2, 1]

Với sự thay thế

randomSample([1, 2, 3, 4, 5, 6], 4) có thể trở lại [2, 3, 3, 2]

var getRandomElements = function(sourceArray, requiredLength) {
    var result = [];
    while(result.length<requiredLength){
        random = Math.floor(Math.random()*sourceArray.length);
        if(result.indexOf(sourceArray[random])==-1){
            result.push(sourceArray[random]);
        }
    }
    return result;
}

Tôi không thể tin rằng không ai không đề cập đến phương pháp này, khá rõ ràng và dễ hiểu.

const getRnd = (a, n) => new Array(n).fill(null).map(() => a[Math.floor(Math.random() * a.length)]);

Đây là câu trả lời đúng nhất và nó sẽ cung cấp cho bạn các yếu tố Ngẫu nhiên + Duy nhất.

function randomize(array, n)
{
    var final = [];
    array = array.filter(function(elem, index, self) {
        return index == self.indexOf(elem);
    }).sort(function() { return 0.5 - Math.random() });

    var len = array.length,
    n = n > len ? len : n;

    for(var i = 0; i < n; i ++)
    {
        final[i] = array[i];
    }

    return final;
}

// randomize([1,2,3,4,5,3,2], 4);
// Result: [1, 2, 3, 5] // Something like this

items.sort (() => (Math.random ()> 0.5? 1: -1)). slice (0, count);