Considérer:

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

Comment puis-je sélectionner une valeur aléatoire dans ce tableau en utilisant JavaScript?

C'est un simple doublure

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

Exemple

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 vous avez déjà inclus un trait de soulignement ou un lodash dans votre projet, vous pouvez l'utiliser _.sample.

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

Si vous devez obtenir plus d'un élément au hasard, vous pouvez le passer comme deuxième argument en soulignement:

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

ou utilisez la _.sampleSizeméthode en lodash:

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

Méthode prototype

Si vous prévoyez d'obtenir une valeur aléatoire beaucoup, vous voudrez peut-être définir une fonction pour elle.

Tout d'abord, mettez ceci dans votre code quelque part:

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

Maintenant:

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

Code publié dans le domaine public sous les termes de la licence CC0 1.0 .

~~est beaucoup plus rapide que Math.Floor(), donc quand il s'agit d'optimiser les performances tout en produisant une sortie en utilisant des éléments d'interface utilisateur, ~~gagne la partie. PLUS D'INFORMATIONS

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

Mais si vous savez que le tableau va avoir des millions d'éléments que vous voudrez peut-être reconsidérer entre l'opérateur au niveau du bit et Math.Floor(), en tant qu'opérateur au niveau du bit, se comporter bizarrement avec de grands nombres. Voir l'exemple ci-dessous expliqué avec la sortie. PLUS D'INFORMATIONS

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

Disons que vous voulez choisir un élément aléatoire différent de la dernière fois (pas vraiment aléatoire, mais toujours une exigence courante) ...

En s'appuyant sur la réponse de @Markus, nous pouvons ajouter une autre fonction prototype:

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

Et implémentez comme ceci:

var myRandomDiffElement = myArray.randomDiffElement(lastRandomElement)

Si vous avez des valeurs fixes (comme une liste de noms de mois) et que vous souhaitez une solution sur une seule ligne

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

La deuxième partie du tableau est une opération d'accès telle que décrite dans Pourquoi [5,6,8,7] [1,2] = 8 en JavaScript?

La version la plus courte:

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

Si vous voulez l'écrire sur une ligne, comme la solution de Pascual, une autre solution serait de l'écrire en utilisant la fonction de recherche d'ES6 (basée sur le fait que la probabilité de sélectionner au hasard un des néléments est 1/n):

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

Utilisez cette approche à des fins de test et s'il existe une bonne raison de ne pas enregistrer le tableau dans une variable distincte uniquement. Sinon, les autres réponses ( floor(random()*lengthet en utilisant une fonction séparée) sont votre voie à suivre.

Faker.js possède de nombreuses fonctions utilitaires pour générer des données de test aléatoires. C'est une bonne option dans le cadre d'une suite de tests:

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

Comme les commentateurs l'ont mentionné, vous ne devez généralement pas utiliser cette bibliothèque dans le code de production.

L'édition d'un prototype de tableau peut être nuisible. Ici, c'est une fonction simple pour faire le travail.

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
}

Usage:

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

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

Fonction récursive et autonome qui peut renvoyer n'importe quel nombre d'éléments (identique à 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])
}

Pour obtenir un tableau de forme d'élément aléatoire crypto-fort, utilisez

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

Ceci est similaire, mais plus général, à la solution de @Jacob Relkin:

C'est ES2015:

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

Le code fonctionne en sélectionnant un nombre aléatoire entre 0 et la longueur du tableau, puis en renvoyant l'élément à cet index.

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

ou version plus courte équivalente:

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

Exemple de code:

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

Fonction simple:

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

À mon avis, mieux que de jouer avec des prototypes ou de le déclarer juste à temps, je préfère l'exposer à la fenêtre:

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

Maintenant, n'importe où sur votre application, vous l'appelez comme:

var rand = window.choice.call(array)

De cette façon, vous pouvez toujours utiliser la for(x in array)boucle correctement

J'ai trouvé un moyen de contourner les complications de la réponse supérieure, simplement en concaténant la variable rand à une autre variable qui permet d'afficher ce nombre à l'intérieur de l'appel de myArray [] ;. En supprimant le nouveau tableau créé et en jouant avec ses complications, j'ai trouvé une solution de travail:

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

Vous définissez une variable constante sur le tableau, vous avez ensuite une autre constante qui choisit au hasard entre les trois objets du tableau, puis la fonction renvoie simplement les résultats.

Une façon générique d'obtenir des éléments aléatoires:

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 rend cela un peu plus simple et lisible:

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

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

Voici un exemple de la façon de procéder:

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

une autre méthode simple:

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

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

Créez une valeur aléatoire et passez au tableau

Veuillez essayer le code suivant.

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