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

## between two (15)

Au lieu de `Math.random()` , vous pouvez utiliser `crypto.getRandomValues()` pour générer des nombres aléatoires cryptographiquement sécurisés distribués uniformément. Voici un exemple:

``````function randInt(min, max) {
var MAX_UINT32 = 0xFFFFFFFF;
var range = max - min;

if (!(range <= MAX_UINT32)) {
throw new Error(
"Range of " + range + " covering " + min + " to " + max + " is > " +
MAX_UINT32 + ".");
} else if (min === max) {
return min;
} else if (!(max > min)) {
throw new Error("max (" + max + ") must be >= min (" + min + ").");
}

// We need to cut off values greater than this to avoid bias in distribution
// over the range.
var maxUnbiased = MAX_UINT32 - ((MAX_UINT32 + 1) % (range + 1));

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

var offset = rand % (range + 1);
return min + offset;
}

console.log(randInt(-8, 8));          // -2
console.log(randInt(0, 0));           // 0
console.log(randInt(0, 0xFFFFFFFF));  // 944450079
console.log(randInt(-1, 0xFFFFFFFF));
// Uncaught Error: Range of 4294967296 covering -1 to 4294967295 is > 4294967295.
console.log(new Array(24).fill().map(n => randInt(8, 12)));
// [11, 8, 8, 11, 10, 8, 8, 12, 12, 12, 9, 9,
//  11, 8, 11, 8, 8, 8, 11, 9, 10, 12, 9, 11]
console.log(randInt(10, 8));
// Uncaught Error: max (8) must be >= min (10).``````

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) dans JavaScript?

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

Ou, en Underscore

``````_.random(min, max)
``````

# Math.random()

Dans la documentation de Math.random() Developer Network:

``````// Returns a random integer between min (included) and max (included)

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

D'autres solutions

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

J'ai trouvé que la solution de Francisc ci-dessus n'incluait pas le nombre min ou max dans les résultats, donc je l'ai modifié comme ceci:

``````function randomInt(min,max)
{
return Math.floor(Math.random()*(max-(min+1))+(min+1));
}
``````

La fonction Math.random () renvoie un nombre pseudo-aléatoire à virgule flottante dans la plage [0, 1); c'est-à-dire de 0 (inclusivement) jusqu'à 1 (excluant)

Ajoutons le `min` `randomly` de `0` à `max-min`

# Cas 0

`min` + 0 * ( `max` - `min` ) = min

# Cas 1

`min` + 1 * ( `max` - `min` ) = max

# Cas aléatoire en utilisant Math.random 0 <= r <1

`min` + r * ( `max` - `min` ) = X , où X a une plage de min <= X < max

Le résultat ci-dessus X est un nombre aléatoire. Cependant, en raison de Math.random (), notre limite gauche est inclusive et la limite droite est exclusive. Pour inclure notre limite droite, nous augmentons la limite droite de 1 et le résultat du plancher.

``````function generateRandomInteger(min, max) {
return Math.floor(min + Math.random()*(max+1 - min))
}
``````

# Pour obtenir le nombre aléatoire

`generateRandomInteger(-20, 20)` ;

Exemple

Renvoie un nombre aléatoire entre 1 et 10:

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

Le résultat pourrait être: `3`

Essayez-vous: here

-

ou en utilisant lodash / undescore:

`_.random(min, max)`

Docs: - lodash.com/docs#random - Underscore

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

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

``````var x = 6; // can be any number
var rand = Math.floor(Math.random()*x) + 1;
``````

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

Entier aléatoire : 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;
}
``````

Random Floating Point Number : pour obtenir un nombre à virgule flottante aléatoire entre `min` et `max` , utilisez le code suivant

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

Référence: Math.random()

Les mathématiques ne sont pas mon point fort, mais j'ai travaillé sur un projet où j'avais besoin de 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 faites rien d'autre que des chiffres. Assurez-vous également que min est toujours inférieur ou égal à max.

Si vous voulez obtenir entre 1 et 6, vous devez calculer:

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

J'ai écrit une fonction plus flexible qui peut vous donner un nombre aléatoire mais pas seulement un nombre 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 corrigée

Exemple pour le premier point de dlaliberte:

Une fermeture n'est pas créée uniquement lorsque vous retournez une fonction interne. En fait, la fonction englobante n'a pas besoin de revenir du tout. Vous pouvez plutôt affecter votre fonction interne à une variable d'une étendue externe ou la transmettre en tant qu'argument à une autre fonction où elle pourrait être utilisée immédiatement. Par conséquent, la fermeture de la fonction englobante existe probablement déjà au moment où la fonction englobante a été appelée, car toute fonction interne y a accès dès qu'elle est appelée.

``````var i;
function foo(x) {
var tmp = 3;
i = function (y) {
console.log(x + y + (++tmp));
}
}
foo(2);
i(3);
``````