Рассматривать:

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

Как я могу выбрать случайное значение из этого массива, используя JavaScript?

Это простой однострочник

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

пример

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

Если у вас уже есть подчеркивание или перевод текста, вы можете использовать их _.sample.

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

Если вам нужно получить более одного элемента случайным образом, вы можете передать это в качестве второго аргумента в подчеркивании:

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

или используйте _.sampleSizeметод в lodash:

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

Метод прототипа

Если вы планируете много получать случайное значение, вы можете определить для него функцию.

Во-первых, поместите это в свой код где-нибудь:

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

Сейчас же:

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

Код передан в общественное достояние в соответствии с условиями лицензии CC0 1.0 .

~~намного быстрее, чем Math.Floor(), поэтому, когда дело доходит до оптимизации производительности при создании вывода с использованием элементов пользовательского интерфейса, ~~выигрывает игра. БОЛЬШЕ ИНФОРМАЦИИ

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

Но если вы знаете, что в массиве будут миллионы элементов, вы, возможно, захотите пересмотреть Math.Floor()битовый оператор, поскольку битовый оператор ведет себя странно с большими числами. См. Пример ниже, объясненный с выходом. БОЛЬШЕ ИНФОРМАЦИИ

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

Скажем, вы хотите выбрать случайный предмет, который отличается от прошлого раза (не совсем случайный, но все же распространенное требование) ...

Основываясь на ответе @Markus, мы можем добавить еще одну функцию-прототип:

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

И реализовать так:

var myRandomDiffElement = myArray.randomDiffElement(lastRandomElement)

Если у вас есть фиксированные значения (например, список названий месяцев) и вы хотите однострочное решение

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

Вторая часть массива - это операция доступа, как описано в разделе Почему [5,6,8,7] [1,2] = 8 в JavaScript?

Самая короткая версия:

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

Если вы хотите записать его в одну строку, как решение Паскуаля, другое решение было бы написать его, используя функцию поиска ES6 (основываясь на том факте, что вероятность случайного выбора одного из nэлементов равна 1/n):

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

Используйте этот подход для целей тестирования, и если есть веская причина не сохранять массив только в отдельной переменной. В противном случае другие ответы ( floor(random()*lengthи использование отдельной функции) - ваш путь.

В Faker.js есть много утилит для генерации случайных тестовых данных. Это хороший вариант в контексте набора тестов:

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

Как отметили комментаторы, вы вообще не должны использовать эту библиотеку в рабочем коде.

Редактирование прототипа Array может быть вредным. Здесь это простая функция, чтобы сделать работу.

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
}

Применение:

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

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

Рекурсивная, автономная функция, которая может возвращать любое количество элементов (идентично 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])
}

Чтобы получить криптостойкий массив случайных элементов, используйте

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

Это похоже, но более общее, чем решение @Jacob Relkin:

Это ES2015:

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

Код работает, выбирая случайное число в диапазоне от 0 до длины массива, а затем возвращает элемент с этим индексом.

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

или эквивалентная более короткая версия:

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

Образец кода:

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

Простая функция:

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

ИЛИ

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

ИЛИ

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

На мой взгляд, лучше, чем возиться с прототипами или объявлять их вовремя, я предпочитаю выставлять их в окне:

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

Теперь в любом месте вашего приложения вы называете это как:

var rand = window.choice.call(array)

Таким образом, вы все еще можете использовать for(x in array)цикл правильно

Я нашел способ обойти сложности верхнего ответа, просто связав переменную rand с другой переменной, которая позволяет отображать это число внутри вызова myArray [] ;. Удалив созданный новый массив и поиграв с его сложностями, я нашел рабочее решение:

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

Вы устанавливаете постоянную переменную для массива, затем у вас есть другая константа, которая выбирает случайным образом между тремя объектами в массиве, а затем функция просто возвращает результаты.

Общий способ получить случайный элемент (ы):

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 делает это немного более простым и читаемым:

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

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

Вот пример того, как это сделать:

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

другой простой метод:

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

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

Создайте одно случайное значение и передайте в массив

Пожалуйста, попробуйте следующий код ..

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