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?
Si vous voulez avoir entre 1 et 6, calculez:
Math.floor(Math.random() * 6) + 1
Où:
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é.
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;
Autres solutions:
(Math.random() * 6 | 0) + 1
~~(Math.random() * 6) + 1
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
var x = 6; // can be any number
var Rand = Math.floor(Math.random()*x) + 1;
Ou, dans Soulignement
_.random(min, max)
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.
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.
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;
}
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));
}
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.
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))
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;
}
Cela devrait fonctionner:
const getRandomNum = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min
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
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 BigInt
s 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]