Rozważać:

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

Jak mogę wybrać losową wartość z tej tablicy za pomocą JavaScript?

Jest to prosty jednowarstwowy

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

Przykład

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

Jeśli masz już podkreślenie lub lodash w swoim projekcie, możesz użyć _.sample.

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

Jeśli potrzebujesz losowo uzyskać więcej niż jeden przedmiot, możesz przekazać to jako drugi argument w podkreśleniu:

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

lub użyj _.sampleSizemetody w lodash:

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

Metoda prototypowa

Jeśli planujesz często uzyskiwać losową wartość, możesz chcieć zdefiniować dla niej funkcję.

Najpierw umieść to gdzieś w kodzie:

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

Teraz:

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

Kod wydany do domeny publicznej zgodnie z warunkami licencji CC0 1.0 .

~~jest znacznie szybszy niż Math.Floor(), więc jeśli chodzi o optymalizację wydajności podczas tworzenia danych wyjściowych przy użyciu elementów interfejsu użytkownika, ~~wygrywa. WIĘCEJ INFORMACJI

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

Ale jeśli wiesz, że tablica będzie zawierać miliony elementów, możesz ponownie rozważyć między operatorem Math.Floor()bitowym i , ponieważ operator bitowy zachowuje się dziwnie z dużymi liczbami. Zobacz poniższy przykład objaśniony z danymi wyjściowymi. WIĘCEJ INFORMACJI

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

Powiedzmy, że chcesz wybrać losowy przedmiot, który różni się od ostatniego razu (niezbyt losowy, ale wciąż powszechny wymóg) ...

Opierając się na odpowiedzi @Markus, możemy dodać kolejną funkcję prototypową:

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

I zaimplementuj tak:

var myRandomDiffElement = myArray.randomDiffElement(lastRandomElement)

Jeśli masz ustalone wartości (np. Listę nazw miesięcy) i potrzebujesz rozwiązania jednowierszowego

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

Druga część tablicy to operacja dostępu opisana w Dlaczego w [5,6,8,7] [1,2] = 8 w JavaScript?

Najkrótsza wersja:

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

Jeśli chcesz napisać go w jednym wierszu, tak jak rozwiązanie Pascuala, innym rozwiązaniem byłoby napisanie go za pomocą funkcji wyszukiwania ES6 (w oparciu o fakt, że prawdopodobieństwo losowego wybrania jednego z nelementów wynosi 1/n):

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

Zastosuj to podejście do celów testowych i jeśli istnieje uzasadniony powód, aby nie zapisywać tablicy tylko w osobnej zmiennej. W przeciwnym razie pozostałe odpowiedzi ( floor(random()*lengthi korzystanie z oddzielnej funkcji) są na dobrej drodze.

Faker.js ma wiele funkcji narzędziowych do generowania losowych danych testowych. Jest to dobra opcja w kontekście zestawu testów:

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

Jak wspomnieli komentatorzy, ogólnie nie powinieneś używać tej biblioteki w kodzie produkcyjnym.

Edycja prototypu tablicy może być szkodliwa. Tutaj jest to prosta funkcja do wykonania pracy.

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
}

Stosowanie:

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

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

Rekurencyjna, samodzielna funkcja, która może zwrócić dowolną liczbę elementów (identyczne jak 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])
}

Aby uzyskać silną kryptowalutę losową formę formularza, użyj tablicy

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

Jest to podobne, ale bardziej ogólne niż rozwiązanie @Jacob Relkin:

To jest ES2015:

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

Kod działa, wybierając losową liczbę z zakresu od 0 do długości tablicy, a następnie zwracając element pod tym indeksem.

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

lub równoważna krótsza wersja:

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

Przykładowy kod:

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

Prosta funkcja:

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

LUB

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

LUB

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

Moim zdaniem, lepiej niż zadzierać z prototypami lub zadeklarować go w samą porę, wolę wystawiać go na okno:

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

Teraz w dowolnym miejscu aplikacji możesz ją nazwać:

var rand = window.choice.call(array)

W ten sposób nadal możesz for(x in array)prawidłowo używać pętli

Znalazłem sposób na ominięcie komplikacji odpowiedzi, po prostu łącząc zmienną rand z inną zmienną, która umożliwia wyświetlanie tej liczby w wywołaniu myArray [] ;. Usuwając utworzoną nową tablicę i bawiąc się jej komplikacjami, wymyśliłem działające rozwiązanie:

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

Ustawiasz stałą zmienną na tablicę, a następnie masz inną stałą, która wybiera losowo między trzema obiektami w tablicy, a następnie funkcja po prostu zwraca wyniki.

Ogólny sposób uzyskiwania losowych elementów:

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 sprawia, że ​​jest to trochę prostsze i czytelniejsze:

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

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

Oto przykład, jak to zrobić:

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

inna łatwa metoda:

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

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

Utwórz jedną losową wartość i przekaż do tablicy

Spróbuj wykonać następujący kod ..

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