我正在研究“如何从 javascript 中的数组中随机访问元素”。我发现了很多关于这个的链接。喜欢： 从 JavaScript 数组中获取随机项
var item = items[Math.floor(Math.random()*items.length)];
但是在这种情况下，我们只能从数组中选择一项。如果我们想要多个元素，那么我们该如何实现呢？我们如何从一个数组中获取多个元素？
问问题
130778 次
24 回答
255
只有两行：
// 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);
演示：
于 2016-07-25T14:57:52.430 回答
177
试试这个非破坏性（和快速）的功能：
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;
}
于 2013-10-09T10:52:37.590 回答
30
这里有一个单行独特的解决方案
array.sort(() => Math.random() - Math.random()).slice(0, n)
于 2019-09-27T02:26:14.197 回答
16
lodash _.sample和_.sampleSize.
从集合的唯一键处获取一个或 n 个随机元素，直到集合的大小。
_.sample([1, 2, 3, 4]);
// => 2
_.sampleSize([1, 2, 3], 2);
// => [3, 1]
_.sampleSize([1, 2, 3], 3);
// => [2, 3, 1]
于 2020-04-09T03:04:59.820 回答
13
.sample从 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) / Math.log(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;
}
从Lib/random.py移植的实现。
笔记：
setsize是根据 Python 中的特性设置的以提高效率。尽管尚未针对 JavaScript 进行调整，但该算法仍将按预期运行。- 根据 ECMAScript 规范，由于滥用
Array.prototype.sort. 然而，该算法保证在有限时间内终止。 - 对于尚未
Set实现的旧浏览器，该集合可以替换为 anArray并.has(j)替换为.indexOf(j) > -1.
针对公认答案的表现：
- https://jsperf.com/pick-random-elements-from-an-array
- Safari 上的性能差异最大。
于 2017-08-07T22:55:52.057 回答
12
创建一个执行此操作的函数：
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;
}
您还应该检查 sourceArray 是否有足够的元素返回。如果要返回唯一元素，则应从 sourceArray 中删除选定元素。
于 2013-10-09T10:37:05.733 回答
12
在不改变原始数组的情况下获得 5 个随机项：
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);
（不要将它用于大列表）
于 2018-03-25T19:12:32.513 回答
8
如果您想在循环中从数组中随机获取项目而不重复，您可以使用以下命令从数组中删除所选项目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);于 2013-10-09T10:41:37.210 回答
7
ES6 语法
const pickRandom = (arr,count) => {
let _arr = [...arr];
return[...Array(count)].map( ()=> _arr.splice(Math.floor(Math.random() * _arr.length), 1)[0] );
}
于 2019-03-27T09:58:50.133 回答
4
我不敢相信没有人没有提到这种方法，非常干净和直接。
const getRnd = (a, n) => new Array(n).fill(null).map(() => a[Math.floor(Math.random() * a.length)]);
于 2020-02-13T21:13:38.240 回答
3
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();
于 2013-10-09T10:47:16.777 回答
3
这是一个很好的打字版本。它不会失败。如果样本大小大于原始数组的长度，则返回一个混洗数组。
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);
于 2019-07-20T12:52:49.637 回答
2
在这个答案中，我想与您分享我必须知道的最佳方法的测试，该方法使所有元素都有相同的机会具有随机子数组。
方法01
array.sort(() => Math.random() - Math.random()).slice(0, n)
使用这种方法，与其他元素相比，某些元素具有更高的机会。
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)方法二
使用这种方法，元素具有相同的概率：
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)正确答案发布在以下链接中：https ://stackoverflow.com/a/46545530/3811640
于 2019-12-03T13:23:44.363 回答
2
2020 年
无损函数式编程风格，在不可变的环境中工作。
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));于 2020-10-04T10:24:50.733 回答
1
编辑：如果您只想获取几个元素，则此解决方案比此处介绍的其他解决方案（拼接源数组）要慢。这种解法的速度只取决于原始数组中元素的数量，而拼接解法的速度取决于输出数组中所需元素的数量。
如果你想要不重复的随机元素，你可以打乱你的数组，然后只得到你想要的数量：
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
演示：http: //jsbin.com/UHUHuqi/1/edit
从这里获取的随机播放功能：https ://stackoverflow.com/a/6274398/1669279
于 2013-10-09T10:40:02.590 回答
1
我需要一个函数来解决这类问题，所以我在这里分享它。
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);
注意：如果n = arr.length那么基本上你正在洗牌数组arr并randomItems返回那个洗牌的数组。
于 2019-02-26T16:12:38.043 回答
1
这是@Derek 从 Python 移植的代码的优化版本，添加了破坏性（就地）选项，如果您可以使用它，它可以使其成为最快的算法。否则，它要么制作完整副本，要么对于从大数组请求的少量项目，切换到基于选择的算法。
// 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) / Math.log(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 => pool[i]);
}
}
与 Derek 的实现相比，第一个算法在 Firefox 中要快得多，而在 Chrome 中要慢一些，尽管现在它具有破坏性选项 - 性能最高的选项。第二种算法只是快了 5-15%。我尽量不给出任何具体数字，因为它们会因 k 和 n 的不同而有所不同，并且可能在未来对新的浏览器版本没有任何意义。
在算法之间进行选择的启发式方法源自 Python 代码。我保持原样，尽管它有时会选择较慢的那个。它应该针对 JS 进行优化，但这是一项复杂的任务，因为极端情况的性能取决于浏览器及其版本。例如，当您尝试从 1000 或 1050 中选择 20 时，它将相应地切换到第一种或第二种算法。在这种情况下，第一个在 Chrome 80 中的运行速度比第二个快 2 倍，但在 Firefox 74 中慢 3 倍。
于 2020-04-07T10:46:47.710 回答
0
这是我使用的一个函数，可让您轻松地对数组进行采样，无论是否替换：
// 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;
};
使用它很简单：
没有替换（默认行为）
randomSample([1, 2, 3], 2)可能会回来[2, 1]
更换
randomSample([1, 2, 3, 4, 5, 6], 4)可能会回来[2, 3, 3, 2]
于 2019-07-27T08:37:11.547 回答
0
它从 srcArray 中一个一个地提取随机元素，而它已经足够了，或者 srcArray 中没有更多的元素可供提取。快速可靠。
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;
}于 2018-08-30T17:46:04.637 回答
0
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;
}
于 2019-09-16T07:04:47.707 回答
0
采样可能重复：
const sample_with_duplicates = Array(sample_size).fill().map(() => items[~~(Math.random() * items.length)])
无重复抽样：
const sample_without_duplicates = [...Array(items.length).keys()].sort(() => 0.5 - Math.random()).slice(0, sample_size).map(index => items[index]);
由于没有重复需要首先对整个索引数组进行排序，因此它比大输入数组的可能重复要慢得多。items
显然，没有重复的最大大小是 <=items.length
于 2022-01-31T06:25:34.567 回答
-2
items.sort(() => (Math.random() > 0.5 ? 1 : -1)).slice(0, count);
于 2019-12-27T15:38:00.040 回答
-2
2019
这与Laurynas Mališauskas的回答相同，只是元素是唯一的（没有重复）。
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;
}
现在回答原始问题“如何通过jQuery获取多个随机元素”，你去：
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');
于 2019-02-17T12:27:16.680 回答
-2
这是最正确的答案，它会给你随机+独特的元素。
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
于 2016-12-26T11:10:23.610 回答