Comment puis-je créer un tableau avec 40 éléments, avec des valeurs aléatoires de 0 à 39? Comme

[4, 23, 7, 39, 19, 0, 9, 14, ...]

J'ai essayé d'utiliser des solutions d'ici:

http://freewebdesigntutorials.com/javaScriptTutorials/jsArrayObject/randomizeArrayElements.htm

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

Voici une solution qui mélange une liste de nombres uniques (aucune répétition, jamais).

for (var a=[],i=0;i<40;++i) a[i]=i;

// http://stackoverflow.com/questions/962802#962890
function shuffle(array) {
  var tmp, current, top = array.length;
  if(top) while(--top) {
    current = Math.floor(Math.random() * (top + 1));
    tmp = array[current];
    array[current] = array[top];
    array[top] = tmp;
  }
  return array;
}

a = shuffle(a);

Si vous voulez autoriser des valeurs répétées (ce qui n'est pas ce que l'OP voulait), cherchez ailleurs. :)

L'approche la plus courte (ES6)

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

Prendre plaisir!

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

Approche ES6 encore plus courte:

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

En outre, vous pouvez avoir une fonction avec des arguments:

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

Le plus court :-)

[...Array(40)].map(e=>~~(Math.random()*40))

Math.random()renverra un nombre entre 0 et 1 (exclusif). Donc, si vous voulez 0-40, vous pouvez le multiplier par 40, le résultat le plus élevé est celui que vous multipliez.

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 nombres successifs ...

Les séquences d'éléments aléatoires contiennent souvent des blocs de nombres successifs, voir l' erreur du joueur . Par exemple:

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

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

limité le tableau à 6 valeurs pour le rendre facile à voir.

Étant donné que la plage de nombres est limitée, je dirais que la meilleure chose à faire est de générer le tableau, de le remplir avec les nombres de zéro à 39 (dans l'ordre), puis de 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 seconde @Pointy et @Phrogz si vous voulez éviter les doublons dans votre tableau sans avoir à faire de calculs coûteux

Solutions monolignes originales tous les jours.

Les valeurs dans les tableaux sont totalement aléatoires, donc lorsque vous utiliserez ces extraits, ce sera différent.

Un tableau (longueur 10) avec des caractères aléatoires 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 de dates aléatoires (d'il y a 10 ans à maintenant)

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.000Z, 2007-07-17T21: 00: 00.000Z,
2015-05-05T21: 00: 00.000Z, 2011-06-14T21: 00: 00.000Z,
2009-07-23T21 : 00: 00.000Z, 2009-11-13T22: 00: 00.000Z,
2010-05-09T21: 00: 00.000Z, 2008-01-05T22: 00: 00.000Z,
2016-05-06T21: 00: 00.000Z, 2014-08-06T21: 00: 00.000Z]

Un tableau (longueur 10) 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']

D'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 désormais ê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: les fonctions fléchées et Array.from ().

Reportez-vous ci-dessous: -

let arr = Array.apply(null, {length: 1000}).map(Function.call, Math.random)
/* will create array with 1000 elements */

à partir 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 sens que je devais créer un tableau avec un certain nombre de nombres aléatoires distincts détenus dans une plage spécifiée. Voici 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 se retrouver avec beaucoup d'appels inutiles (si votre nombre et votre portée sont élevés et proches du même nombre) mais c'est le meilleur que je puisse trouver.

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 résoudra le problème des probabilités, uniquement limité par le générateur de nombres aléatoires.

Si vous en avez besoin avec des valeurs uniques aléatoires de 0 ... plage de longueur:

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]

Je suis à peu près sûr que c'est le moyen le plus court de créer votre tableau aléatoire sans aucune répétition

var random_array = new Array(40).fill().map((a, i) => a = i).sort(() => Math.random() - 0.5);

Un peu tard à la fête, mais j'utilise randojs.com pour le hasard car cela rend des choses comme ça super faciles. Vous pouvez obtenir un tableau aléatoire de nombres de 0 à 39 comme ceci:

console.log(randoSequence(40));

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

Pas de problème avec la logistique de tout cela - en plus c'est super lisible et facile à comprendre :)

Générateurs

Un tableau de longueur 40 de 40 valeurs aléatoires possibles (0 - 39) sans valeurs répétées est préférable de le mélanger comme l'expliquent @Phrogz et @Jared Beck. Une autre approche, juste pour les enregistrements, pourrait être l'utilisation de générateurs. Mais cette approche manque de performances par rapport aux autres solutions proposées .

function* generateRandomIterable(n, range) {
  for (let i = 0; i < n; i++) {
    yield ~~(Math.random() * range);
  }
}
const randomArr = [...generateRandomIterable(40,40)];