web-dev-qa-db-fra.com

Générer un nombre aléatoire entre deux nombres en JavaScript

Existe-t-il un moyen de générer un nombre aléatoire dans une plage spécifiée (par exemple, de 1 à 6: 1, 2, 3, 4, 5 ou 6) en JavaScript?

javascriptrandom
1407
Mirgorod

Si vous voulez avoir entre 1 et 6, calculez:

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

Où: 

  • 1 est le numéro de départ 
  • 6 est le nombre de résultats possibles (1 + début (6) - fin (1) )
1760
khr055
function randomIntFromInterval(min,max) // min and max included
{
    return Math.floor(Math.random()*(max-min+1)+min);
}

Ce qui est "extra", c'est qu'il permet des intervalles aléatoires qui ne commencent pas par 1 . Vous pouvez donc obtenir un nombre aléatoire de 10 à 15 par exemple. La flexibilité.

1833
Francisc

Math.random ()

Dans la documentation Mozilla Developer Network:

// Returns a random integer between min (include) and max (include)

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;
224
Lior Elrom

Autres solutions:

  • (Math.random() * 6 | 0) + 1
  • ~~(Math.random() * 6) + 1
82
Vishal

jsfiddle: https://jsfiddle.net/cyGwf/477/

Random Integer: pour obtenir un entier aléatoire entre min et max, utilisez le code suivant

function getRandomInteger(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min)) + min;
}

Nombre à virgule flottante aléatoire: pour obtenir un nombre à virgule flottante aléatoire compris entre min et max, utilisez le code suivant

function getRandomFloat(min, max) {
  return Math.random() * (max - min) + min;
}

Référence: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random

19
Razan Paul
var x = 6; // can be any number
var Rand = Math.floor(Math.random()*x) + 1;
18
ryebr3ad

Ou, dans Soulignement

_.random(min, max)
18
vladiim

Les maths ne sont pas mon point fort, mais je travaille sur un projet dans lequel je devais générer beaucoup de nombres aléatoires entre positifs et négatifs. 

function randomBetween(min, max) {
    if (min < 0) {
        return min + Math.random() * (Math.abs(min)+max);
    }else {
        return min + Math.random() * max;
    }
}

Par exemple 

randomBetween(-10,15)//or..
randomBetween(10,20)//or...
randomBetween(-200,-100)

Bien sûr, vous pouvez également ajouter une validation pour vous assurer que vous ne le faites pas avec autre chose que des chiffres. Assurez-vous également que min est toujours inférieur ou égal à max.

13
Petter Thowsen

J'ai écrit une fonction plus flexible qui peut vous donner un nombre aléatoire mais pas seulement un entier.

function Rand(min,max,interval)
{
    if (typeof(interval)==='undefined') interval = 1;
    var r = Math.floor(Math.random()*(max-min+interval)/interval);
    return r*interval+min;
}

var a = Rand(0,10); //can be 0, 1, 2 (...) 9, 10
var b = Rand(4,6,0.1); //can be 4.0, 4.1, 4.2 (...) 5.9, 6.0

Version fixe.

8
ElChupacabra

Je cherchais un générateur de nombre aléatoire écrit en TypeScript et je l’ai écrit après avoir lu toutes les réponses, en espérant que cela fonctionnerait pour les codeurs TypeScript.

    Rand(min: number, max: number): number {
        return (Math.random() * (max - min + 1) | 0) + min;
    }
4
Erdi İzgi

Malgré de nombreuses réponses et presque le même résultat. J'aimerais ajouter ma réponse et expliquer son fonctionnement. Parce qu'il est important de comprendre son fonctionnement plutôt que de copier-coller un code de ligne. Générer des nombres aléatoires n'est rien d'autre que des maths simples. 

CODE:

function getR(lower, upper) {

  var percent = (Math.random() * 100);
  // this will return number between 0-99 because Math.random returns decimal number from 0-0.9929292 something like that
  //now you have a percentage, use it find out the number between your INTERVAL :upper-lower 
  var num = ((percent * (upper - lower) / 100));
  //num will now have a number that falls in your INTERVAL simple maths
  num += lower;
  //add lower to make it fall in your INTERVAL
  //but num is still in decimal
  //use Math.floor>downward to its nearest integer you won't get upper value ever
  //use Math.ceil>upward to its nearest integer upper value is possible
  //Math.round>to its nearest integer 2.4>2 2.5>3   both lower and upper value possible
  console.log(Math.floor(num), Math.ceil(num), Math.round(num));
}
4
Arun Sharma

Sense que vous devez ajouter 1 au nombre maximum, puis soustraire le nombre minimum pour que tout cela fonctionne, et je dois faire beaucoup d’entiers aléatoires, cette fonction fonctionne.

var random = function(max, min) {
    high++;
    return Math.floor((Math.random()) * (max - min)) + min;
};

Cela fonctionne avec les nombres négatifs et positifs, et je travaille sur les décimales pour une bibliothèque.

2
Travis

Afin de créer un nombre aléatoire en javascript, nous pouvons utiliser l'objet javascript Math intégré. L'objet Math contient une fonction Math.random(). Cette fonction effectue les opérations suivantes (source MDN):

La fonction Math.random () renvoie un pseudo-aléatoire pseudo-aléatoire nombre compris entre 0 et 1 (y compris 0, mais pas 1) avec approximativement distribution uniforme sur cette plage - que vous pouvez ensuite adapter à votre gamme désirée.

Étant donné cette fonctionnalité, nous pouvons facilement l’intégrer dans des scénarios plus complexes. Par exemple:

function randomNR (x, y){
return Math.round((Math.random() * x + y));
}

// dice >> random number between 1-6
// dice functionality without function >> Math.round((Math.random() * 5 + 1))
console.log(randomNR(5,1));


// coin >> random number between 0-1
// coin functionality without function >> Math.round((Math.random() * 1))
console.log(randomNR(1,0))

1
Willem van der Veen

J'ai découvert une nouvelle façon de faire cela en utilisant les paramètres par défaut de l'ES6. C'est très astucieux car il permet un ou deux arguments. C'est ici:

function random(n, b = 0) {
    return Math.random() * (b-n) + n;
}
0
maburdi94

Cela devrait fonctionner:

const getRandomNum = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min
0
sbr_amd

Ajout de float avec une version à précision fixe basée sur la version int dans la réponse de @ Francisc:

function randomFloatFromInterval (min, max, fractionDigits) {
  const fractionMultiplier = Math.pow(10, fractionDigits)
  return Math.round(
    (Math.random() * (max - min) + min) * fractionMultiplier,
  ) / fractionMultiplier
}

alors:

randomFloatFromInterval(1,3,4) // => 2.2679, 1.509, 1.8863, 2.9741, ...

et pour la réponse int

randomFloatFromInterval(1,3,0) // => 1, 2, 3
0
yonatanmn

Math.random() est rapide et convient à de nombreuses fins, mais cela ne convient pas si vous avez besoin de valeurs cryptographiquement sécurisées (ce n'est pas sécurisé), ou si vous avez besoin d'entiers d'une distribution non uniforme totalement uniforme (l'approche de multiplication utilisée dans d'autres réponses produit certaines valeurs légèrement plus souvent que d'autres).

Dans de tels cas, nous pouvons utiliser crypto.getRandomValues() pour générer des entiers sécurisés et rejeter les valeurs générées que nous ne pouvons pas mapper de manière uniforme dans la plage cible. Cela sera plus lent, mais cela ne devrait pas être important, sauf si vous générez un très grand nombre de valeurs.

Pour clarifier le problème de la distribution biaisée, considérons le cas où nous voulons générer une valeur comprise entre 1 et 5, mais nous avons un générateur de nombres aléatoires qui produit des valeurs comprises entre 1 et 16 (une valeur de 4 bits). Nous voulons avoir le même nombre de valeurs générées mappées sur chaque valeur de sortie, mais 16 ne se divise pas également par 5: il reste un reste de 1. Nous avons donc besoin de rejeter 1 des valeurs générées possibles et de continuer uniquement lorsque nous obtenons une des 15 valeurs inférieures qui peuvent être uniformément cartographiées dans notre plage cible. Notre comportement pourrait ressembler à ce pseudocode:

Generate a 4-bit integer in the range 1-16.
If we generated  1,  6, or 11 then output 1.
If we generated  2,  7, or 12 then output 2.
If we generated  3,  8, or 13 then output 3.
If we generated  4,  9, or 14 then output 4.
If we generated  5, 10, or 15 then output 5.
If we generated 16 then reject it and try again.

Le code suivant utilise une logique similaire, mais génère à la place un entier 32 bits, car il s'agit de la plus grande taille d'entier commune pouvant être représentée par le type number standard de JavaScript. (Cela pourrait être modifié pour utiliser BigInts si vous avez besoin d’une plage plus large.) Quelle que soit la plage choisie, la fraction des valeurs générées rejetées sera toujours inférieure à 0,5; le nombre attendu de rejets sera toujours inférieur à 1,0 et généralement proche de 0,0; vous n'avez pas besoin de vous soucier de la boucle pour toujours.

const randomInteger = (min, max) => {
  const range = max - min;
  const maxGeneratedValue = 0xFFFFFFFF;
  const possibleResultValues = range + 1;
  const possibleGeneratedValues = maxGeneratedValue + 1;
  const remainder = possibleGeneratedValues % possibleResultValues;
  const maxUnbiased = maxGeneratedValue - remainder;

  if (!Number.isInteger(min) || !Number.isInteger(max) ||
       max > Number.MAX_SAFE_INTEGER || min < Number.MIN_SAFE_INTEGER) {
    throw new Error('Arguments must be safe integers.');
  } else if (range > maxGeneratedValue) {
    throw new Error(`Range of ${range} (from ${min} to ${max}) > ${maxGeneratedValue}.`);
  } else if (max < min) {
    throw new Error(`max (${max}) must be >= min (${min}).`);
  } else if (min === max) {
    return min;
  } 

  let generated;
  do {
    generated = crypto.getRandomValues(new Uint32Array(1))[0];
  } while (generated > maxUnbiased);

  return min + (generated % possibleResultValues);
};

console.log(randomInteger(-8, 8));          // -2
console.log(randomInteger(0, 0));           // 0
console.log(randomInteger(0, 0xFFFFFFFF));  // 944450079
console.log(randomInteger(-1, 0xFFFFFFFF));
// Error: Range of 4294967296 covering -1 to 4294967295 is > 4294967295.
console.log(new Array(12).fill().map(n => randomInteger(8, 12)));
// [11, 8, 8, 11, 10, 8, 8, 12, 12, 12, 9, 9]
0
Jeremy