Prendere in considerazione:

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

Come posso selezionare un valore casuale da questo array usando JavaScript?

È una semplice linea

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

Esempio

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

Se hai già un carattere di sottolineatura o lodash incluso nel tuo progetto, puoi usarlo _.sample.

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

Se è necessario ottenere più di un elemento in modo casuale, è possibile passarlo come secondo argomento nel trattino basso:

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

o usa il _.sampleSizemetodo in lodash:

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

Metodo prototipo

Se hai intenzione di ottenere un valore casuale molto, potresti voler definire una funzione per esso.

Innanzitutto, inseriscilo nel tuo codice da qualche parte:

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

Adesso:

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

Codice rilasciato di pubblico dominio ai sensi della licenza CC0 1.0 .

~~è molto più veloce di Math.Floor(), quindi quando si tratta di ottimizzazione delle prestazioni durante la produzione di output utilizzando elementi dell'interfaccia utente, ~~vince il gioco. ULTERIORI INFORMAZIONI

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

Ma se sai che l'array avrà milioni di elementi di quelli che potresti voler riconsiderare tra Operatore Bitwise e Math.Floor(), poiché l' operatore Bitwise si comporta in modo strano con numeri grandi. Vedi l'esempio seguente spiegato con l'output. ULTERIORI INFORMAZIONI

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

Supponi di voler scegliere un oggetto casuale diverso dall'ultima volta (non proprio casuale, ma comunque un requisito comune) ...

Sulla base della risposta di @Markus, possiamo aggiungere un'altra funzione prototipo:

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

E implementare in questo modo:

var myRandomDiffElement = myArray.randomDiffElement(lastRandomElement)

Se hai valori fissi (come un elenco di nomi di mese) e desideri una soluzione a una riga

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

La seconda parte dell'array è un'operazione di accesso come descritto in Perché [5,6,8,7] [1,2] = 8 in JavaScript?

La versione più corta:

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

Se si desidera scriverlo su una riga, come la soluzione di Pascual, un'altra soluzione sarebbe quella di scriverlo utilizzando la funzione di ricerca di ES6 (in base al fatto, che la probabilità di selezionare casualmente uno degli nelementi è 1/n):

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

Utilizzare tale approccio a scopo di test e se esiste una buona ragione per non salvare l'array solo in una variabile separata. Altrimenti le altre risposte ( floor(random()*lengthe usando una funzione separata) sono la tua strada da percorrere.

Faker.js ha molte funzioni di utilità per la generazione di dati di test casuali. È una buona opzione nel contesto di una suite di test:

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

Come hanno già detto i commentatori, generalmente non dovresti usare questa libreria nel codice di produzione.

La modifica del prototipo di array può essere dannosa. Qui è una semplice funzione per fare il lavoro.

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
}

Uso:

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

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

Funzione ricorsiva e autonoma che può restituire un numero qualsiasi di elementi (identico a 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])
}

Per ottenere l' uso di array di oggetti casuali criptati

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

Questo è simile, ma più generale, alla soluzione di @Jacob Relkin:

Questo è ES2015:

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

Il codice funziona selezionando un numero casuale compreso tra 0 e la lunghezza dell'array, quindi restituendo l'elemento in quell'indice.

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

o versione abbreviata equivalente:

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

Codice di esempio:

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

Funzione semplice:

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

O

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

O

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

Secondo me, meglio che scherzare con i prototipi o dichiararlo appena in tempo, preferisco esporlo alla finestra:

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

Ora ovunque nella tua app la chiami come:

var rand = window.choice.call(array)

In questo modo è ancora possibile utilizzare il for(x in array)loop correttamente

Ho trovato un modo per aggirare le complicazioni della risposta più alta, semplicemente concatenando la variabile rand a un'altra variabile che consente a quel numero di essere visualizzato nella chiamata di myArray [] ;. Eliminando il nuovo array creato e giocando con le sue complicazioni, ho trovato una soluzione funzionante:

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

Impostate una variabile costante sull'array, quindi avete un'altra costante che sceglie casualmente tra i tre oggetti dell'array e quindi la funzione restituisce semplicemente i risultati.

Un modo generico per ottenere elementi casuali:

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 rende questo un po 'più semplice e leggibile:

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

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

Ecco un esempio di come farlo:

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

un altro metodo semplice:

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

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

Crea un valore casuale e passa all'array

Si prega di provare il seguente codice ..

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