Considerar:

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

Como posso selecionar um valor aleatório dessa matriz usando JavaScript?

É um one-liner simples

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

Exemplo

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 você já possui sublinhado ou lodash incluído no seu projeto, pode usar _.sample.

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

Se você precisar obter mais de um item aleatoriamente, poderá passar isso como um segundo argumento em sublinhado:

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

ou use o _.sampleSizemétodo no lodash:

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

Método de protótipo

Se você planeja obter muito um valor aleatório, pode definir uma função para ele.

Primeiro, coloque isso no seu código em algum lugar:

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

Agora:

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

Código liberado para o domínio público sob os termos da licença CC0 1.0 .

~~é muito mais rápido que Math.Floor(), portanto, quando se trata de otimização de desempenho enquanto produz saída usando elementos da interface do usuário, ~~vence o jogo. MAIS INFORMAÇÕES

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

Mas se você souber que a matriz terá milhões de elementos, poderá reconsiderar entre o Bitwise Operator e Math.Floor(), como o operador bit a bit se comporta estranhamente com grandes números. Veja o exemplo abaixo explicado com a saída. MAIS INFORMAÇÕES

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

Digamos que você queira escolher um item aleatório diferente da última vez (não muito aleatório, mas ainda um requisito comum) ...

Com base na resposta de @Markus, podemos adicionar outra função de protótipo:

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 implemente da seguinte maneira:

var myRandomDiffElement = myArray.randomDiffElement(lastRandomElement)

Se você tiver valores fixos (como a lista de nomes do mês) e quiser uma solução de uma linha

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

A segunda parte da matriz é uma operação de acesso, conforme descrito em Por que [5,6,8,7] [1,2] = 8 em JavaScript?

A versão mais curta:

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

Se você deseja escrevê-lo em uma linha, como a solução de Pascual, outra solução seria escrevê-lo usando a função find do ES6 (com base no fato de que a probabilidade de selecionar aleatoriamente um dos nitens é 1/n):

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

Use essa abordagem para fins de teste e se houver um bom motivo para não salvar a matriz apenas em uma variável separada. Caso contrário, as outras respostas ( floor(random()*lengthe usando uma função separada) são o seu caminho.

O Faker.js possui muitas funções utilitárias para gerar dados de teste aleatórios. É uma boa opção no contexto de um conjunto de testes:

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

Como os comentaristas mencionaram, geralmente você não deve usar esta biblioteca no código de produção.

A edição do protótipo da matriz pode ser prejudicial. Aqui está uma função simples de fazer o trabalho.

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

Função autônoma recursiva que pode retornar qualquer número de itens (idêntico ao 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 obter uma matriz de formulários aleatórios de itens com criptografia forte, 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) )

Isso é semelhante, mas mais genérico, à solução de @Jacob Relkin:

Este é o ES2015:

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

O código funciona selecionando um número aleatório entre 0 e o comprimento da matriz, retornando o item nesse índice.

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

ou versão mais curta equivalente:

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

Código de amostra:

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

Função simples:

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

OU

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

OU

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

Na minha opinião, melhor do que mexer com protótipos ou declará-lo bem a tempo, prefiro expô-lo à janela:

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

Agora em qualquer lugar do seu aplicativo, você chama assim:

var rand = window.choice.call(array)

Dessa forma, você ainda pode usar o for(x in array)loop corretamente

Eu encontrei uma maneira de contornar as complicações da resposta principal, apenas concatenando a variável rand para outra variável que permite que esse número seja exibido dentro da chamada de myArray [] ;. Ao excluir a nova matriz criada e brincar com suas complicações, criei uma solução funcional:

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

Você define uma variável constante para a matriz, em seguida, tem outra constante que escolhe aleatoriamente entre os três objetos na matriz e a função simplesmente retorna os resultados.

Uma maneira genérica de obter elementos aleatórios:

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

O randojs torna isso um pouco mais simples e legível:

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

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

Aqui está um exemplo de como fazê-lo:

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

outro método fácil:

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

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

Crie um valor aleatório e passe para a matriz

Por favor, tente o seguinte 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);