Il existe quelques exemples sur la page Mozilla Developer Network :

 /** * Returns a random number between min (inclusive) and max (exclusive) */ function getRandomArbitrary(min, max) { return Math.random() * (max - min) + min; } /** * Returns a random integer between min (inclusive) and max (inclusive) * Using Math.round() will give you a non-uniform distribution! */ function getRandomInt(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; } 

Voilà la logique derrière. C'est une règle simple de trois:

Math.random() renvoie un Number compris entre 0 (inclus) et 1 (exclusif). Nous avons donc un intervalle comme ceci:

 [0 .................................... 1) 

Maintenant, nous aimerions un nombre compris entre min (inclus) et max (exclusif):

 [0 .................................... 1) [min .................................. max) 

Nous pouvons utiliser Math.random pour obtenir le correspondant dans l'intervalle [min, max). Mais, d'abord, nous devrions prendre en compte un peu le problème en soustrayant le min Du deuxième intervalle:

 [0 .................................... 1) [min - min ............................ max - min) 

Cela donne:

 [0 .................................... 1) [0 .................................... max - min) 

Nous pouvons maintenant appliquer Math.random , puis calculer le correspondant. Choisissons un nombre aléatoire:

  Math.random() | [0 .................................... 1) [0 .................................... max - min) | x (what we need) 

Donc, afin de trouver x , nous ferions:

 x = Math.random() * (max - min); 

N'oubliez pas d'ajouter min back, afin que nous obtenions un nombre dans l'intervalle [min, max)

 x = Math.random() * (max - min) + min; 

C'était la première fonction de MDN. Le second renvoie un nombre entier entre min et max , tous deux inclus.

Maintenant, pour obtenir des nombres entiers, vous pouvez utiliser le round , le ceil ou le floor .

Vous pouvez utiliser Math.round(Math.random() * (max - min)) + min , mais cela donne une distribution non-uniforme. Les deux, min et max n'ont que la moitié de la chance de rouler:

 min...min+0.5...min+1...min+1.5 ... max-0.5....max └───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘ ← Math.round() min min+1 max 

Avec le max exclu de l'intervalle, il a encore moins de chance de rouler que de min .

Avec Math.floor(Math.random() * (max - min +1)) + min vous disposez d'une distribution parfaitement Math.floor(Math.random() * (max - min +1)) + min .

 min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval) | | | | | | └───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘ ← Math.floor() min min+1 max-1 max 

Vous ne pouvez pas utiliser ceil() et -1 dans cette équation parce que max maintenant eu un peu moins de chance de rouler, mais vous pouvez également lancer le résultat (indésirable) min-1 .

 var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum; 

 function getRandomizer(bottom, top) { return function() { return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom; } } 

usage:

 var rollDie = getRandomizer( 1, 6 ); var results = "" for ( var i = 0; i<1000; i++ ) { results += rollDie() + " "; //make a string filled with 1000 random numbers in the range 1-6. } 

panne:

Nous retournons une fonction (en empruntant à la programmation fonctionnelle) qui, lorsqu'on l'appelle, renverra un entier aléatoire entre les valeurs bottom et top , inclusivement. Nous disons «inclusif» car nous voulons inclure à la fois le bas et le haut de la gamme des nombres qui peuvent être retournés. De cette façon, getRandomizer( 1, 6 ) renverra 1, 2, 3, 4, 5 ou 6.

(Le bas est le nombre inférieur, le haut est le plus grand nombre)

 Math.random() * ( 1 + top - bottom ) 

Math.random() renvoie un double aléatoire entre 0 et 1, et si nous le multiplions par un plus la différence entre le top et le bottom , nous aurons un double entre 0 et 1+ba .

 Math.floor( Math.random() * ( 1 + top - bottom ) ) 

Math.floor arrondit le nombre à l'entier le plus proche. Nous avons maintenant tous les nombres entiers entre 0 et le top-bottom . Le 1 semble déroutant, mais il doit être là parce que nous arrondions toujours, donc le numéro supérieur ne sera jamais atteint sans lui. Les décimales aléatoires que nous générons doivent être dans la plage de 0 à (1+top-bottom) afin que nous puissions arrondir et obtenir un int dans la plage 0 vers le top-bottom

 Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom 

Le code de l'exemple précédent nous a donné un nombre entier dans la gamme 0 et en top-bottom , donc tout ce que nous devons faire maintenant est d'ajouter bottom à ce résultat pour obtenir un nombre entier dans la gamme bottom et top inclusive. :RÉ

REMARQUE: si vous passez une valeur non entière ou que le plus grand nombre d'abord, vous obtiendrez un comportement indésirable, mais à moins que quelqu'un ne le demande, je ne vais pas approfondir dans le code de vérification de l'argument car c'est plutôt loin de l'intention de la question initiale .

Math.random ()

À partir de la documentation Mozilla Developer Network:

 // Returns a random integer between min and max function getRandomInt(min, max) { return Math.floor(Math.random() * (max - min + 1)) + min; } 

Exemples utiles:

 // 0 - 10 Math.floor(Math.random() * 11); // 1 - 10 Math.floor(Math.random() * 10) + 1; // 5 - 20 Math.floor(Math.random() * 16) + 5; // -10 - (-2) Math.floor(Math.random() * 9) - 10; 

 function randomRange(min, max) { return ~~(Math.random() * (max - min + 1)) + min } 

Alternative si vous utilisez Underscore.js vous pouvez utiliser

 _.random(min, max) 

Renvoie un nombre aléatoire entre 1 et 10:

 Math.floor((Math.random()*10) + 1); 

Renvoie un nombre aléatoire entre 1 et 100:

 Math.floor((Math.random()*100) + 1) 

Les autres réponses ne tiennent pas compte des paramètres parfaitement raisonnables de 0 et 1 . Au lieu de cela, vous devriez utiliser le round place du ceil ou du floor :

 function randomNumber(minimum, maximum){ return Math.round( Math.random() * (maximum - minimum) + minimum); } console.log(randomNumber(0,1)); # 0 1 1 0 1 0 console.log(randomNumber(5,6)); # 5 6 6 5 5 6 console.log(randomNumber(3,-1)); # 1 3 1 -1 -1 -1 

Après avoir généré un nombre aléatoire en utilisant un programme informatique, il est toujours considéré comme un nombre aléatoire si le nombre choisi est une partie ou la totalité de la première. Mais si cela a été changé, les mathématiciens ne l'acceptent pas comme un nombre aléatoire et ils peuvent l'appeler un nombre biaisé. Mais si vous développez un programme pour une tâche simple, ce ne sera pas un cas à considérer. Mais si vous développez un programme pour générer un nombre aléatoire pour des éléments précieux tels que le programme de loterie ou le jeu de jeu, votre programme sera rejeté par la direction si vous ne considérez pas le cas ci-dessus.

Donc, pour ce genre de personnes, voici ma suggestion:

Générer un nombre aléatoire à l'aide de Math.random() . ( Math.random() ce n )

 Now for [0,10) ==> n*10 (ie one digit) and for[10,100) ==> n*100 (ie two digits) and so on. Here squire bracket indicates that boundary is inclusive and round bracket indicates boundary is exclusive. Then remove the rest after the decimal point. (ie get floor) - using Math.floor(), this can be done. 

Si vous savez comment lire la table des nombres aléatoires pour choisir un nombre aléatoire, vous savez que le processus ci-dessus (en multipliant par 1, 10, 100, etc.) ne viole pas celui auquel j'ai été mentionné au début. (Parce qu'il ne change que le Lieu de la virgule.)

Etudiez l'exemple suivant et développez-le selon vos besoins.

Si vous avez besoin d'un échantillon [0,9] alors le plancher de n * 10 est votre réponse et si nécessaire [0,99] alors le plancher de n * 100 est votre réponse et ainsi de suite.

Maintenant, laissez entrer votre rôle:

Vous avez demandé des nombres parmi une gamme spécifique. (Dans ce cas, vous êtes biaisé parmi cette gamme. – En prenant un numéro de [1,6] par un déroulement, vous êtes partial dans [1,6], mais il est toujours aléatoire si et seulement si la mort est impartiale .)

Considérez donc votre gamme ==> [78, 247] nombre d'éléments de la plage = 247 – 78 + 1 = 170; (Puisque les deux limites sont inclusives).

 /*Mthod 1:*/ var i = 78, j = 247, k = 170, a = [], b = [], c, d, e, f, l = 0; for(; i <= j; i++){ a.push(i); } while(l < 170){ c = Math.random()*100; c = Math.floor(c); d = Math.random()*100; d = Math.floor(d); b.push(a[c]); e = c + d; if((b.length != k) && (e < k)){ b.push(a[e]); } l = b.length; } console.log('Method 1:'); console.log(b); /*Method 2:*/ var a, b, c, d = [], l = 0; while(l < 170){ a = Math.random()*100; a = Math.floor(a); b = Math.random()*100; b = Math.floor(b); c = a + b; if(c <= 247 || c >= 78){ d.push(c); }else{ d.push(a); } l = d.length; } console.log('Method 2:'); console.log(d); 

Remarque: Dans la méthode 1, j'ai d'abord créé un tableau qui contient des nombres dont vous avez besoin, puis les mets de manière aléatoire dans un autre tableau. Dans la méthode deux, génère des nombres au hasard et vérifiez que ceux sont dans la gamme dont vous avez besoin. Ensuite, mettez-le dans un tableau. Ici, j'ai généré deux nombres aléatoires et utilisé leur total pour maximiser la vitesse du programme en minimisant le taux d'échec que l'obtention d'un nombre utile. Cependant, l'ajout de nombres générés donnera également une certaine contrainte. Je recommanderais donc ma première méthode pour générer des nombres aléatoires dans une gamme spécifique.

Dans les deux méthodes, votre console affichera le résultat. (Appuyez sur f12 dans Chrome pour ouvrir la console)

Pour un entier aléatoire avec une plage, essayez:

 function random(minimum, maximum) { var bool = true; while (bool) { var number = (Math.floor(Math.random() * maximum + 1) + minimum); if (number > 20) { bool = true; } else { bool = false; } } return number; } 

Pour obtenir un nombre aléatoire, dites entre 1 et 6, faites d'abord:

  0.5 + (Math.random() * ((6 - 1) + 1)) 

Ceci multiplie par 6 un nombre aléatoire puis ajoute 0,5. Prochain cycle du nombre à un nombre entier positif en effectuant:

  Math.round(0.5 + (Math.random() * ((6 - 1) + 1)) 

Ce nombre est égal au numéro entier le plus proche.

Ou pour rendre plus compréhensible, procédez comme suit:

  var value = 0.5 + (Math.random() * ((6 - 1) + 1)) var roll = Math.round(value); return roll; 

En général, le code pour ce faire en utilisant des variables est:

  var value = (Min - 0.5) + (Math.random() * ((Max - Min) + 1)) var roll = Math.round(value); return roll; 

La raison de retirer 0,5 de la valeur minimale est que l'utilisation de la valeur minimale seule vous permettrait d'obtenir un nombre entier supérieur à votre valeur maximale. En supprimant 0,5 de la valeur minimale, vous empêchez essentiellement l'arrondi de la valeur maximale.

J'espère que cela pourra aider.

En utilisant le code suivant, vous pouvez générer un tableau de nombres aléatoires, sans répéter, dans une plage donnée.

 function genRandomNumber(how_many_number,min,max) { // parameters // how_many_number : how many numbers you want to generate. For example it is 5. // min(inclusive) : minimum/low value of a range. it must be any positive integer but less than max. ie 4 // max(inclusive) : maximun value of a range. it must be any positive integer. ie 50 // return type: array var random_number = []; for (var i = 0; i < how_many_number; i++) { var gen_num = parseInt((Math.random() * (max-min+1)) + min); do { var is_exist = random_number.indexOf(gen_num); if (is_exist >= 0) { gen_num = parseInt((Math.random() * (max-min+1)) + min); } else { random_number.push(gen_num); is_exist = -2; } } while (is_exist > -1); } document.getElementById('box').innerHTML = random_number; } 

Voici la mise en œuvre MS DotNet de la classe aléatoire dans javascript-

 var Random = (function () { function Random(Seed) { if (!Seed) { Seed = this.milliseconds(); } this.SeedArray = []; for (var i = 0; i < 56; i++) this.SeedArray.push(0); var num = (Seed == -2147483648) ? 2147483647 : Math.abs(Seed); var num2 = 161803398 - num; this.SeedArray[55] = num2; var num3 = 1; for (var i_1 = 1; i_1 < 55; i_1++) { var num4 = 21 * i_1 % 55; this.SeedArray[num4] = num3; num3 = num2 - num3; if (num3 < 0) { num3 += 2147483647; } num2 = this.SeedArray[num4]; } for (var j = 1; j < 5; j++) { for (var k = 1; k < 56; k++) { this.SeedArray[k] -= this.SeedArray[1 + (k + 30) % 55]; if (this.SeedArray[k] < 0) { this.SeedArray[k] += 2147483647; } } } this.inext = 0; this.inextp = 21; Seed = 1; } Random.prototype.milliseconds = function () { var str = new Date().valueOf().toString(); return parseInt(str.substr(str.length - 6)); }; Random.prototype.InternalSample = function () { var num = this.inext; var num2 = this.inextp; if (++num >= 56) { num = 1; } if (++num2 >= 56) { num2 = 1; } var num3 = this.SeedArray[num] - this.SeedArray[num2]; if (num3 == 2147483647) { num3--; } if (num3 < 0) { num3 += 2147483647; } this.SeedArray[num] = num3; this.inext = num; this.inextp = num2; return num3; }; Random.prototype.Sample = function () { return this.InternalSample() * 4.6566128752457969E-10; }; Random.prototype.GetSampleForLargeRange = function () { var num = this.InternalSample(); var flag = this.InternalSample() % 2 == 0; if (flag) { num = -num; } var num2 = num; num2 += 2147483646.0; return num2 / 4294967293.0; }; Random.prototype.Next = function (minValue, maxValue) { if (!minValue && !maxValue) return this.InternalSample(); var num = maxValue - minValue; if (num <= 2147483647) { return parseInt((this.Sample() * num + minValue).toFixed(0)); } return this.GetSampleForLargeRange() * num + minValue; }; Random.prototype.NextDouble = function () { return this.Sample(); }; Random.prototype.NextBytes = function (buffer) { for (var i = 0; i < buffer.length; i++) { buffer[i] = this.InternalSample() % 256; } }; return Random; }()); 

Utilisation:

  var r = new Random(); var nextInt = r.Next(1, 100); //returns an integer between range var nextDbl = r.NextDouble(); //returns a random decimal