créer un tableau avec des valeurs aléatoires en javascript

La plus courte approche (ES6)

// randomly generated N = 40 length array 0 <= A[N] <= 39
Array.from({length: 40}, () => Math.floor(Math.random() * 40));

Profitez-en!

ES5:

function randomArray(length, max) {
    return Array.apply(null, Array(length)).map(function() {
        return Math.round(Math.random() * max);
    });
}

ES6:

randomArray = (length, max) => [...new Array(length)]
    .map(() => Math.round(Math.random() * max));

Math.random() retournera un nombre entre 0 et 1(exclusif). Donc, si vous voulez 0-40, vous pouvez le multiplier par 40, le plus haut résultat que le résultat puisse jamais être est ce que vous multipliez par.

var arr = [];
for (var i=0, t=40; i<t; i++) {
    arr.push(Math.round(Math.random() * t))
}
document.write(arr);

http://jsfiddle.net/robert/tUW89 /

.. le tableau que j'obtiens est très peu aléatoire. Il génère beaucoup de blocs de numéros successifs...

séquences d'articles aléatoires contiennent souvent des blocs de nombres successifs, voir le Fallacy du Joueur . Par exemple:

.. nous venons de lancer quatre têtes d'affilée .. Puisque la probabilité de une série de cinq têtes successives n'est que de 1⁄32 .. une personne assujettie à l' l'erreur du joueur pourrait croire que ce prochain flip était moins susceptible de chefs que d'être queues. http://en.wikipedia.org/wiki/Gamblers_fallacy

Encore plus courte ES6 approche:

Array(40).fill().map(() => Math.round(Math.random() * 40))

aussi, vous pouvez avoir une fonction avec des arguments:

const randomArray = (length, max) => 
  Array(length).fill().map(() => Math.round(Math.random() * max))

puisque la gamme des nombres est limitée, je dirais que la meilleure chose à faire est de générer le tableau, le remplir avec des nombres de zéro à 39 (dans l'ordre), puis le mélanger.

var myArray = [];
var arrayMax = 40;
var limit = arrayMax + 1;
for (var i = 0; i < arrayMax; i++) {
  myArray.push(Math.floor(Math.random()*limit));
}

ceci ci-dessus est la façon traditionnelle de le faire, mais je deuxième @Pointy et @Phrogz si vous voulez éviter les doublons dans votre tableau sans avoir à faire de calcul coûteux

Caprice d'une seule ligne de solutions sur tous les jours.

les valeurs dans les tableaux sont totalement aléatoires, donc quand vous utiliserez ce snippets, il sera différent.

Un tableau (longueur 10) avec aléatoire de caractères en minuscules

Array.apply(null, Array(10)).map(function() { return String.fromCharCode(Math.floor(Math.random() * (123 - 97) + 97)); })

['k',' a',' x',' y',' n',' w',' m',' q',' b',' j']

Un tableau (longueur 10) avec des nombres entiers aléatoires de 0 à 99

Array.apply(null, Array(10)).map(function() { return Math.floor(Math.random() * 100 % 100); })

[ 86, 77, 83, 27, 79, 96, 67, 75, 52, 21 ]

Un tableau aléatoire dates (à partir de 10 ans à ans à aujourd'hui)

Array.apply(null, Array(10)).map(function() { return new Date((new Date()).getFullYear() - Math.floor(Math.random() * 10), Math.floor(Math.random() * 12), Math.floor(Math.random() * 29) )})

[ 2008-08-22T21: 00: 00.000 Z, 2007-07-17T21:00: 00.000 Z,

2015-05-05T21:00: 00.000 Z, 2011-06-14T21:00: 00.000 Z,

2009-07-23T21:00: 00.000 Z, 2009-11-13T22: 00: 00.000 Z,

2010-05-09T21:00: 00.000 Z, 2008-01-05T22:00: 00.000 Z,

2016-05-06T21:00: 00.000 Z, 2014-08-06T21:00: 00.000 Z]

Un tableau (longueur 10) des chaînes aléatoires

Array.apply(null, Array(10)).map(function() { return Array.apply(null, Array(Math.floor(Math.random() * 10  + 3))).map(function() { return String.fromCharCode(Math.floor(Math.random() * (123 - 97) + 97)); }).join('') });

['cubjjhaph', "bmwy", "alhobd", "ceud", "tnyullyn", "vpkdflarhnf", "hvg", "arazuln", "jzz", 'cyx']

autres choses utiles que vous pouvez trouver ici https://github.com/setivolkylany/nodejs-utils/blob/master/utils/faker.js

en utilisant de nouvelles fonctionnalités ES6, cela peut maintenant être réalisé en utilisant:

function getRandomInt(min, max) {
    "use strict";
    if (max < min) {
        // Swap min and max
        [min, max] = [min, max];
    }

    // Generate random number n, where min <= n <= max
    let range = max - min + 1;
    return Math.floor(Math.random() * range) + min;
}

let values = Array.from({length: 40}, () => getRandomInt(0, 40));

console.log(values);

notez que cette solution ne fonctionnera que dans les navigateurs modernes qui prennent en charge ces fonctionnalités ES6: arrow functions et Array.de.)(

de la page suggérée par @Phrogz

for (var i=0,nums=[];i<49;i++) nums[i]={ n:i, rand:Math.random() };
nums.sort( function(a,b){ a=a.rand; b=b.rand; return a<b?-1:a>b?1:0 } );

j'avais besoin de quelque chose d'un peu différent de ce que ces solutions donnaient, en ce que j'avais besoin de créer un tableau avec un nombre de nombres aléatoires distincts tenus à une plage spécifiée. Ci-dessous est ma solution.

function getDistinctRandomIntForArray(array, range){
   var n = Math.floor((Math.random() * range));
   if(array.indexOf(n) == -1){        
    return n; 
   } else {
    return getDistinctRandomIntForArray(array, range); 
   }
}

function generateArrayOfRandomInts(count, range) {
   var array = []; 
   for (i=0; i<count; ++i){
    array[i] = getDistinctRandomIntForArray(array, range);
   };
   return array; 
}

j'aurais préféré ne pas créer une boucle qui a la possibilité de faire beaucoup d'appels inutiles (si votre compte, et la gamme est élevé et à peu près le même nombre), mais c'est le mieux que je pouvais venir.

function shuffle(maxElements) {
    //create ordered array : 0,1,2,3..maxElements
    for (var temArr = [], i = 0; i < maxElements; i++) {
        temArr[i] = i;
    }

    for (var finalArr = [maxElements], i = 0; i < maxElements; i++) {
        //remove rundom element form the temArr and push it into finalArrr
        finalArr[i] = temArr.splice(Math.floor(Math.random() * (maxElements - i)), 1)[0];
    }

    return finalArr
}

je suppose que cette méthode va résoudre le problème avec les probabilités, seulement limité par générateur de nombres aléatoires.

let randomNumber = Array.from({length: 6}, () => Math.floor(Math.random() * 39));

limited le tableau 6 valeurs pour le rendre facile à voir.

si vous en avez besoin avec des valeurs uniques aléatoires de 0...gamme de longueurs:

const randomRange = length => {
  const results = []
  const possibleValues = Array.from({ length }, (value, i) => i)

  for (let i = 0; i < length; i += 1) {
    const possibleValuesRange = length - (length - possibleValues.length)
    const randomNumber = Math.floor(Math.random() * possibleValuesRange)
    const normalizedRandomNumber = randomNumber !== possibleValuesRange ? randomNumber : possibleValuesRange

    const [nextNumber] = possibleValues.splice(normalizedRandomNumber, 1)

    results.push(nextNumber)
  }

  return results
}

randomRange(5) // [3, 0, 1, 4, 2]