Erwägen:

var myArray = ['January', 'February', 'March'];    

Wie kann ich mit JavaScript einen zufälligen Wert aus diesem Array auswählen?

Es ist ein einfacher Einzeiler

const randomElement = array[Math.floor(Math.random() * array.length)];

Beispiel

const months = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
const randomMonth = months[Math.floor(Math.random() * months.length)];

console.log("random month =>", randomMonth);

Wenn du schon hast Ihr Projekt Unterstriche oder Lodash enthält , können Sie diese verwenden _.sample.

// will return one item randomly from the array
_.sample(['January', 'February', 'March']);

Wenn Sie mehr als ein Element zufällig erhalten müssen, können Sie dies als zweites Argument im Unterstrich übergeben:

// will return two items randomly from the array using underscore
_.sample(['January', 'February', 'March'], 2);

oder verwenden Sie die _.sampleSizeMethode in lodash:

// will return two items randomly from the array using lodash
_.sampleSize(['January', 'February', 'March'], 2);

Prototyp-Methode

Wenn Sie vorhaben, häufig einen zufälligen Wert zu erhalten, möchten Sie möglicherweise eine Funktion dafür definieren.

Fügen Sie dies zunächst irgendwo in Ihren Code ein:

Array.prototype.sample = function(){
  return this[Math.floor(Math.random()*this.length)];
}

Jetzt:

[1,2,3,4].sample() //=> a random element

Code, der unter den Bedingungen der CC0 1.0-Lizenz öffentlich zugänglich ist .

~~ist viel schneller als Math.Floor(), also wenn es um Leistungsoptimierung bei der Produktion von Ausgaben mit UI-Elementen geht, ~~gewinnt das Spiel. MEHR INFO

var rand = myArray[~~(Math.random() * myArray.length)];

Wenn Sie jedoch wissen, dass das Array Millionen von Elementen enthalten wird, sollten Sie zwischen Bitwise Operator und Bitwise Operator Math.Floor()mit großen Zahlen ein seltsames Verhalten erzielen. Siehe das folgende Beispiel, das mit der Ausgabe erklärt wurde. MEHR INFO

var number = Math.floor(14444323231.2); // => 14444323231
var number = 14444323231.2 | 0; // => 1559421343

Angenommen, Sie möchten ein zufälliges Element auswählen, das sich vom letzten Mal unterscheidet (nicht wirklich zufällig, aber dennoch eine häufige Anforderung) ...

Aufbauend auf der Antwort von @Markus können wir eine weitere Prototypfunktion hinzufügen:

Array.prototype.randomDiffElement = function(last) {
   if (this.length == 0) {
      return;
   } else if (this.length == 1) {
      return this[0];
   } else {
      var num = 0;
      do {
         num = Math.floor(Math.random() * this.length);
      } while (this[num] == last);
      return this[num];
   }
}

Und so umsetzen:

var myRandomDiffElement = myArray.randomDiffElement(lastRandomElement)

Wenn Sie feste Werte haben (z. B. eine Monatsnamenliste) und eine einzeilige Lösung wünschen

var result = ['January', 'February', 'March'][Math.floor(Math.random() * 3)]

Der zweite Teil des Arrays ist eine Zugriffsoperation wie unter Warum ist [5,6,8,7] [1,2] = 8 in JavaScript beschrieben?

Die kürzeste Version:

var myArray = ['January', 'February', 'March']; 
var rand = myArray[(Math.random() * myArray.length) | 0]

Wenn Sie es wie die Lösung von Pascual in eine Zeile schreiben möchten, besteht eine andere Lösung darin, es mit der Suchfunktion von ES6 zu schreiben (basierend auf der Tatsache, dass die Wahrscheinlichkeit einer zufälligen Auswahl eines Elements zufällig nist 1/n):

var item = ['A', 'B', 'C', 'D'].find((_, i, ar) => Math.random() < 1 / (ar.length - i));
console.log(item);

Verwenden Sie diesen Ansatz zu Testzwecken und wenn es einen guten Grund gibt, das Array nicht nur in einer separaten Variablen zu speichern. Andernfalls sind die anderen Antworten ( floor(random()*lengthund die Verwendung einer separaten Funktion) Ihr Weg.

Faker.js verfügt über viele Dienstprogrammfunktionen zum Generieren von zufälligen Testdaten. Dies ist eine gute Option im Kontext einer Testsuite:

const Faker = require('faker');
Faker.random.arrayElement(['January', 'February', 'March']);

Wie von Kommentatoren erwähnt, sollten Sie diese Bibliothek im Produktionscode im Allgemeinen nicht verwenden.

Das Bearbeiten des Array-Prototyps kann schädlich sein. Hier ist es eine einfache Funktion, die Arbeit zu erledigen.

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
}

Verwendungszweck:

// Example 1
var item = getArrayRandomElement(['January', 'February', 'March']);

// Example 2
var myArray = ['January', 'February', 'March'];
var item = getArrayRandomElement(myArray);

Rekursive, eigenständige Funktion, die eine beliebige Anzahl von Elementen zurückgeben kann (identisch mit 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])
}

Verwenden Sie, um ein kryptostarkes Formulararray für zufällige Elemente zu erhalten

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

Dies ähnelt der Lösung von @Jacob Relkin, ist jedoch allgemeiner als diese:

Dies ist ES2015:

const randomChoice = arr => {
    const randIndex = Math.floor(Math.random() * arr.length);
    return arr[randIndex];
};

Der Code wählt eine Zufallszahl zwischen 0 und der Länge des Arrays aus und gibt dann das Element an diesem Index zurück.

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

oder gleichwertige kürzere Version:

var item = myArray[(Math.random()*myArray.length)|0];

Beispielcode:

var myArray = ['January', 'February', 'March'];    
var item = myArray[(Math.random()*myArray.length)|0];
console.log('item:', item);

Einfache Funktion:

var myArray = ['January', 'February', 'March'];
function random(array) {
     return array[Math.floor(Math.random() * array.length)]
}
random(myArray);

ODER

var myArray = ['January', 'February', 'March'];
function random() {
     return myArray[Math.floor(Math.random() * myArray.length)]
}
random();

ODER

var myArray = ['January', 'February', 'March'];
function random() {
     return myArray[Math.floor(Math.random() * myArray.length)]
}
random();

Meiner Meinung nach ist es besser, als mit Prototypen herumzuspielen oder sie rechtzeitig zu deklarieren, sie lieber einem Fenster auszusetzen:

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)];
}

Jetzt überall in Ihrer App nennen Sie es wie folgt:

var rand = window.choice.call(array)

Auf diese Weise können Sie die for(x in array)Schleife weiterhin ordnungsgemäß verwenden

Ich habe einen Weg gefunden, um die Komplikationen der Top-Antwort zu umgehen, indem ich die Variable rand mit einer anderen Variablen verkettet habe, mit der diese Nummer im Aufruf von myArray []; angezeigt werden kann. Durch Löschen des neu erstellten Arrays und Herumspielen mit seinen Komplikationen habe ich eine funktionierende Lösung gefunden:

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

static generateMonth() { 
const theDate = ['January', 'February', 'March']; 
const randomNumber = Math.floor(Math.random()*3);
return theDate[randomNumber];
};

Wenn Sie eine Konstantenvariable für das Array festlegen, haben Sie eine weitere Konstante, die zufällig zwischen den drei Objekten im Array auswählt, und die Funktion gibt dann einfach die Ergebnisse zurück.

Ein generischer Weg, um zufällige Elemente zu erhalten:

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;
}

randojs macht dies etwas einfacher und lesbarer:

console.log( rando(['January', 'February', 'March']).value );

<script src="https://randojs.com/1.0.0.js"></script>

Hier ist ein Beispiel dafür:

$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)];

eine andere einfache Methode:

var myArray = ['keke','keko','cano','halo','zirto'];

var randomValue = myArray[Math.round((Math.random()*1000))%myArray.length];

Erstellen Sie einen zufälligen Wert und übergeben Sie ihn an das Array

Bitte versuchen Sie folgenden 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);