Overweeg:
var myArray = ['January', 'February', 'March'];
Hoe kan ik een willekeurige waarde uit deze array selecteren met JavaScript?
Antwoord 1, autoriteit 100%
Het is een simpele oneliner:
const randomElement = array[Math.floor(Math.random() * array.length)];
Bijvoorbeeld:
const months = ["January", "February", "March", "April", "May", "June", "July"];
const random = Math.floor(Math.random() * months.length);
console.log(random, months[random]);Antwoord 2, autoriteit 5%
Als je underscoreof lodashal hebt opgenomen in je project kun je _.samplegebruiken.
// will return one item randomly from the array
_.sample(['January', 'February', 'March']);
Als je meer dan één item willekeurig wilt krijgen, kun je dat als tweede argument in underscore doorgeven:
// will return two items randomly from the array using underscore
_.sample(['January', 'February', 'March'], 2);
of gebruik de _.sampleSizemethode in lodash:
// will return two items randomly from the array using lodash
_.sampleSize(['January', 'February', 'March'], 2);
Antwoord 3, Autoriteit 2%
U kunt overwegen om een functie op het array-prototype te definiëren, om een methode [].sample()die een willekeurig element retourneert.
Eerste, om de prototype-functie te definiëren, plaats deze fragment in uw code:
Array.prototype.sample = function(){
return this[Math.floor(Math.random()*this.length)];
}
Later, om een willekeurig element uit de array te bemonsteren, bel dan gewoon .sample():
[1,2,3,4].sample() //=> a random element
Ik heb deze code-fragmenten vrij in het publieke domein, onder de voorwaarden van de CC0 1.0-licentie .
Antwoord 4, Autoriteit 2%
~~is veel sneller dan Math.Floor(), dus als het gaat om prestatie-optimalisatie tijdens het produceren van uitvoer met behulp van UI-elementen, ~~wint het spel. meer info
var rand = myArray[~~(Math.random() * myArray.length)];
Maar als u weet dat de array miljoenen elementen zal hebben, dan wilt u misschien reconstrueren tussen bitwise-operator en Math.Floor(), omdat bitwise-exploitanten zich raar gedragen met grote aantallen. Zie hieronder voorbeeld uitgelegd met de uitvoer.
var number = Math.floor(14444323231.2); // => 14444323231
var number = 14444323231.2 | 0; // => 1559421343
Antwoord 5
Stel dat je een willekeurig item wilt kiezen dat anders is dan de vorige keer (niet echt willekeurig, maar toch een veelvoorkomende vereiste)…
/**
* Return a random element from an array that is
* different than `last` (as long as the array has > 1 items).
* Return null if the array is empty.
*/
function getRandomDifferent(arr, last = undefined) {
if (arr.length === 0) {
return;
} else if (arr.length === 1) {
return arr[0];
} else {
let num = 0;
do {
num = Math.floor(Math.random() * arr.length);
} while (arr[num] === last);
return arr[num];
}
}
Implementeer als volgt:
const arr = [1,2,3];
const r1 = getRandomDifferent(arr);
const r2 = getRandomDifferent(arr, r1); // r2 is different than r1.
Antwoord 6
Als je vaste waarden hebt (zoals een lijst met maandnamen) en een eenregelige oplossing wilt
var result = ['January', 'February', 'March'][Math.floor(Math.random() * 3)]
Het tweede deel van de array is een toegangsbewerking zoals beschreven in Waarom is [5,6,8,7][1,2] = 8 in JavaScript?
Antwoord 7
De kortste versie:
var myArray = ['January', 'February', 'March'];
var rand = myArray[(Math.random() * myArray.length) | 0]
console.log(rand)Antwoord 8
Als u het op één regel wilt schrijven, zoals de oplossing van Pascual, zou een andere oplossing zijn om het te schrijven met behulp van de functie van ES6 (op basis van het feit dat de waarschijnlijkheid willekeurig één op nItems is 1/n):
var item = ['A', 'B', 'C', 'D'].find((_, i, ar) => Math.random() < 1 / (ar.length - i));
console.log(item);Antwoord 9
faker.js heeft veel nutsfuncties voor het genereren van willekeurige testgegevens. Het is een goede optie in de context van een testsuite:
const Faker = require('faker');
Faker.random.arrayElement(['January', 'February', 'March']);
Zoals commentaren hebben vermeld, moet u deze bibliotheek in het algemeen niet gebruiken in de productiecode.
Antwoord 10
Bewerken van arrayprototype kan schadelijk zijn. Hier is het een eenvoudige functie om het werk te doen.
function getArrayRandomElement (arr) {
if (arr && arr.length) {
return arr[Math.floor(Math.random() * arr.length)];
}
// The undefined will be returned if the empty array was passed
}
Gebruik:
// Example 1
var item = getArrayRandomElement(['January', 'February', 'March']);
// Example 2
var myArray = ['January', 'February', 'March'];
var item = getArrayRandomElement(myArray);
Antwoord 11
Recursieve, zelfstandige functie die een willekeurig aantal items kan retourneren (identiek aan lodash.sampleSize):
function getRandomElementsFromArray(array, numberOfRandomElementsToExtract = 1) {
const elements = [];
function getRandomElement(arr) {
if (elements.length < numberOfRandomElementsToExtract) {
const index = Math.floor(Math.random() * arr.length)
const element = arr.splice(index, 1)[0];
elements.push(element)
return getRandomElement(arr)
} else {
return elements
}
}
return getRandomElement([...array])
}
Antwoord 12
Dit is vergelijkbaar met, maar algemener dan, de oplossing van @Jacob Relkin:
Dit is ES2015:
const randomChoice = arr => {
const randIndex = Math.floor(Math.random() * arr.length);
return arr[randIndex];
};
De code werkt door een willekeurig getal tussen 0 en de lengte van de array te selecteren en vervolgens het item op die index te retourneren.
Antwoord 13
Om een crypto-strongwillekeurig item te krijgen formulier array gebruik
let rndItem = a=> a[rnd()*a.length|0];
let rnd = ()=> crypto.getRandomValues(new Uint32Array(1))[0]/2**32;
var myArray = ['January', 'February', 'March'];
console.log( rndItem(myArray) )Antwoord 14
var item = myArray[Math.floor(Math.random()*myArray.length)];
of gelijkwaardige kortere versie:
var item = myArray[(Math.random()*myArray.length)|0];
Voorbeeldcode:
var myArray = ['January', 'February', 'March'];
var item = myArray[(Math.random()*myArray.length)|0];
console.log('item:', item);Antwoord 15
Eenvoudige functie:
var myArray = ['January', 'February', 'March'];
function random(array) {
return array[Math.floor(Math.random() * array.length)]
}
random(myArray);
OF
var myArray = ['January', 'February', 'March'];
function random() {
return myArray[Math.floor(Math.random() * myArray.length)]
}
random();
OF
var myArray = ['January', 'February', 'March'];
function random() {
return myArray[Math.floor(Math.random() * myArray.length)]
}
random();
Antwoord 16
Ik heb een manier gevonden om de complicaties van het bovenste antwoord te omzeilen, gewoon door de variabele rand samen te voegen met een andere variabele waarmee dat getal kan worden weergegeven in de aanroep van myArray[];. Door de nieuwe array die is gemaakt te verwijderen en te spelen met de complicaties, heb ik een werkende oplossing bedacht:
<!DOCTYPE html>
<html>
<body>
<p id="demo"></p>
<script>
var myArray = ['January', 'February', 'March', 'April', 'May'];
var rand = Math.floor(Math.random() * myArray.length);
var concat = myArray[rand];
function random() {
document.getElementById("demo").innerHTML = (concat);
}
</script>
<button onClick="random();">
Working Random Array generator
</button>
</body>
</html>
Antwoord 17
static generateMonth() {
const theDate = ['January', 'February', 'March'];
const randomNumber = Math.floor(Math.random()*3);
return theDate[randomNumber];
};Antwoord 18
Op zoek naar een echte oneliner kwam ik op dit:
['January', 'February', 'March'].reduce((a, c, i, o) => { return o[Math.floor(Math.random() * Math.floor(o.length))]; })
Antwoord 19
Door een methode toe te voegen aan het prototype van de array kun je gemakkelijk willekeurige waarden krijgen.
In dit voorbeeld kun je enkele of meerdere willekeurige waarden uit een array halen.
Je kunt code testen door op de fragmentknop te klikken.
Array.prototype.random = function(n){
if(n&&n>1){
const a = [];
for(let i = 0;i<n;i++){
a.push(this[Math.floor(Math.random()*this.length)]);
}
return a;
} else {
return this[Math.floor(Math.random()*this.length)];
}
}
const mySampleArray = ['a','b','c','d','e','f','g','h'];
mySampleArray.random(); // return any random value etc. 'a', 'b'
mySampleArray.random(3); //retun an array with random values etc: ['b','f','a'] , ['d','b','d']
alert(mySampleArray.random());
alert(mySampleArray.random(3));Antwoord 20
Methode 1:
- Gebruik de functie Math.random() om het willekeurige getal tussen (0-1, 1 .) te krijgen
exclusief). - Vermenigvuldig het met de arraylengte om de getallen te krijgen
tussen (0-arrayLength). - Gebruik Math.floor() om het indexbereik te krijgen
van (0 tot arrayLength-1).
const arr = [“foo”,”bar”];
const willekeurigPickedString=arr[Math.floor(Math.random() * arr.length)];
console.log(randomlyPickedString);
Methode 2:
- De methode random(a, b) wordt gebruikt om een getal te genereren tussen (a tot b, b exclusief).
- De vloerwaarde nemen om de getallen te laten lopen van (1 tot arrayLength).
- Trek 1 af om de index te krijgen variërend van (0 tot arrayLength-1).
const arr = [“foo”,”bar”];
const willekeurigPickedString=arr[Math.floor(random(1, 5))-1];
console.log(randomlyPickedString);
Antwoord 21
Als je een willekeurig item meer dan eens moet ophalen, dan gebruik je natuurlijk een functie. Eén manier is om van die functie een methode van het Array.prototypete maken, maar daar krijg je normaal gesproken de pest over in dat je met ingebouwde prototypes knoeit.
U kunt de methode echter wel aan de specifieke array zelf toevoegen:
var months = ['January', 'February', 'March'];
months.random = function() {
return this[Math.floor(Math.random()*this.length)];
};
Op die manier kunt u months.random()zo vaak gebruiken als u wilt zonder het generieke Array.prototypete verstoren.
Zoals bij elke willekeurige functie loop je het risico dat je achtereenvolgens dezelfde waarde krijgt. Als u dat niet wilt, moet u de vorige waarde volgen met een andere eigenschap:
months.random=function() {
var random;
while((random=this[Math.floor(Math.random()*this.length)]) == this.previous);
this.previous=random;
return random;
};
Antwoord 22
Naar mijn mening, beter dan te rommelen met prototypes, of het net op tijd te declareren, geef ik er de voorkeur aan om het aan het raam bloot te stellen:
window.choice = function() {
if (!this.length || this.length == 0) return;
if (this.length == 1) return this[0];
return this[Math.floor(Math.random()*this.length)];
}
Nu noem je het overal in je app als volgt:
var rand = window.choice.call(array)
Op deze manier kun je nog steeds de for(x in array)loop correct gebruiken
Antwoord 23
Een generieke manier om willekeurige elementen te krijgen:
let some_array = ['Jan', 'Feb', 'Mar', 'Apr', 'May'];
let months = random_elems(some_array, 3);
console.log(months);
function random_elems(arr, count) {
let len = arr.length;
let lookup = {};
let tmp = [];
if (count > len)
count = len;
for (let i = 0; i < count; i++) {
let index;
do {
index = ~~(Math.random() * len);
} while (index in lookup);
lookup[index] = null;
tmp.push(arr[index]);
}
return tmp;
}Antwoord 24
Hier is een voorbeeld van hoe u dit moet doen:
$scope.ctx.skills = data.result.skills;
$scope.praiseTextArray = [
"Hooray",
"You\'re ready to move to a new skill",
"Yahoo! You completed a problem",
"You\'re doing great",
"You succeeded",
"That was a brave effort trying new problems",
"Your brain was working hard",
"All your hard work is paying off",
"Very nice job!, Let\'s see what you can do next",
"Well done",
"That was excellent work",
"Awesome job",
"You must feel good about doing such a great job",
"Right on",
"Great thinking",
"Wonderful work",
"You were right on top of that one",
"Beautiful job",
"Way to go",
"Sensational effort"
];
$scope.praiseTextWord = $scope.praiseTextArray[Math.floor(Math.random()*$scope.praiseTextArray.length)];
Antwoord 25
randojsmaakt dit een beetje eenvoudiger en leesbaarder:
console.log( rando(['January', 'February', 'March']).value );<script src="https://randojs.com/1.0.0.js"></script>Antwoord 26
Maak één willekeurige waarde en geef deze door aan de array
Probeer de volgende code..
//For Search textbox random value
var myPlaceHolderArray = ['Hotels in New York...', 'Hotels in San Francisco...', 'Hotels Near Disney World...', 'Hotels in Atlanta...'];
var rand = Math.floor(Math.random() * myPlaceHolderArray.length);
var Placeholdervalue = myPlaceHolderArray[rand];
alert(Placeholdervalue);