Considerar:

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

¿Cómo puedo seleccionar un valor aleatorio de esta matriz usando JavaScript?

Es una línea simple

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

Ejemplo

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

Si ya tiene subrayado o lodash incluido en su proyecto, puede usarlo _.sample.

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

Si necesita obtener más de un elemento al azar, puede pasarlo como segundo argumento en guión bajo:

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

o use el _.sampleSizemétodo en lodash:

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

Método de prototipo

Si planea obtener un valor aleatorio mucho, es posible que desee definir una función para él.

Primero, pon esto en tu código en alguna parte:

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

Ahora:

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

Código publicado en el dominio público bajo los términos de la licencia CC0 1.0 .

~~es mucho más rápido que Math.Floor(), por lo que cuando se trata de la optimización del rendimiento al producir resultados utilizando elementos de la interfaz de usuario, ~~gana el juego. MÁS INFORMACIÓN

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

Pero si sabe que la matriz tendrá millones de elementos, es posible que desee reconsiderar entre el Operador a nivel de bits y Math.Floor(), dado que el operador a nivel de bits se comporta de manera extraña con números grandes. Vea el siguiente ejemplo explicado con la salida. MÁS INFORMACIÓN

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

Digamos que desea elegir un elemento aleatorio que sea diferente de la última vez (no realmente aleatorio, pero sigue siendo un requisito común) ...

Sobre la base de la respuesta de @Markus, podemos agregar otra función 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 implementar así:

var myRandomDiffElement = myArray.randomDiffElement(lastRandomElement)

Si tiene valores fijos (como una lista de nombres de mes) y desea una solución de una línea

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

La segunda parte de la matriz es una operación de acceso como se describe en ¿Por qué [5,6,8,7] [1,2] = 8 en JavaScript?

La versión más corta:

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

Si desea escribirlo en una línea, como la solución de Pascual, otra solución sería escribirlo utilizando la función de búsqueda de ES6 (basado en el hecho de que la probabilidad de seleccionar uno de los nelementos al azar es 1/n):

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

Use ese enfoque para fines de prueba y si hay una buena razón para no guardar la matriz solo en una variable separada. De lo contrario, las otras respuestas ( floor(random()*lengthy el uso de una función separada) son su camino a seguir.

Faker.js tiene muchas funciones de utilidad para generar datos de prueba aleatorios. Es una buena opción en el contexto de un conjunto de pruebas:

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

Como los comentaristas han mencionado, generalmente no debe usar esta biblioteca en el código de producción.

La edición del prototipo de matriz puede ser perjudicial. Aquí es una función simple para hacer el trabajo.

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

Función recursiva independiente que puede devolver cualquier número de elementos (idéntico 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])
}

Para obtener una matriz de forma de elemento aleatorio cripto-fuerte, use

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

Esto es similar pero más general que la solución de @Jacob Relkin:

Esto es ES2015:

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

El código funciona seleccionando un número aleatorio entre 0 y la longitud de la matriz, y luego devuelve el elemento en ese índice.

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

o versión equivalente más corta:

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

Código de muestra:

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

Función simple:

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

En mi opinión, mejor que jugar con los prototipos o declararlo justo a tiempo, prefiero exponerlo a la ventana:

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

Ahora, en cualquier lugar de su aplicación, lo llama así:

var rand = window.choice.call(array)

De esta manera, aún puede usar el for(x in array)bucle correctamente

He encontrado una forma de evitar las complicaciones de la respuesta principal, simplemente concatenando la variable rand con otra variable que permite que ese número se muestre dentro de la llamada de myArray [] ;. Al eliminar la nueva matriz creada y jugar con sus complicaciones, he encontrado una solución que funciona:

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

Establece una variable constante en la matriz, luego tiene otra constante que elige aleatoriamente entre los tres objetos en la matriz y luego la función simplemente devuelve los resultados.

Una forma genérica de obtener elementos aleatorios:

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 hace esto un poco más simple y legible:

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

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

Aquí hay un ejemplo de cómo hacerlo:

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

Otro método fácil:

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

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

Crea un valor aleatorio y pasa a la matriz

Intenta seguir el siguiente código ...

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