Générer des nombres entiers aléatoires en JavaScript dans une plage spécifique?


1955

Comment puis-je générer des nombres entiers aléatoires entre deux variables spécifiées dans JavaScript, par exemple, x = 4et en y = 8afficherais-je une 4, 5, 6, 7, 8?


1
voici un aperçu
Dan KK

9
En guise de remarque: pour ceux qui utilisent npm et recherchent une solution rapide, fiable et prête à l'emploi, il y a lodash.random qui peut être facilement requis avec une très petite empreinte (il importera uniquement la méthode elle-même et non la totalité de lodash).
Nobita

Réponses:


3835

Il y a 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).
 * The value is no lower than min (or the next integer greater than min
 * if min isn't an integer) and no greater than max (or the next integer
 * lower than max if max isn't an integer).
 * Using Math.round() will give you a non-uniform distribution!
 */
function getRandomInt(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

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

Math.random()renvoie un Numberentre 0 (inclus) et 1 (exclusif). Nous avons donc un intervalle comme celui-ci:

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

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

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

Nous pouvons utiliser le Math.randompour obtenir le correspondant dans l'intervalle [min, max). Mais, nous devons d'abord factoriser un peu le problème en soustrayant mindu deuxième intervalle:

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

Cela donne:

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

Nous pouvons maintenant postuler Math.randompuis calculer le correspondant. Choisissons un nombre aléatoire:

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

Donc, pour trouver x, nous ferions:

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

N'oubliez pas de rajouter min, pour 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 retourne un entier entre minet max, tous deux inclus.

Maintenant, pour obtenir des entiers, vous pouvez utiliser round, ceilou floor.

Vous pouvez utiliser Math.round(Math.random() * (max - min)) + min, cela donne cependant une distribution non uniforme. Les deux minet maxseulement environ la moitié des chances de lancer:

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

Avec maxexclus de l'intervalle, il a une encore moins de chance de rouler que min.

Avec Math.floor(Math.random() * (max - min +1)) + minvous, la distribution est parfaitement homogène.

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 -1dans cette équation, car maxvous aviez désormais un peu moins de chances de lancer, mais vous pouvez également obtenir le résultat (indésirable) min-1.


10
Il ne fait cela que parce qu'il appelle floor, ce qui arrondit.
Josh Stodola

4
@ thezachperson31 Vous pouvez utiliser round, mais les deux, minet maxseulement la moitié des chances de rouler comme le font les autres chiffres. Vous pouvez également en soustraire un et le prendre ceil. Cela laisse cependant le maxnombre avec un minimum de chances de rouler en raison de l' [0,1)intervalle.
Christoph

12
J'ai créé un JSFiddle si quelqu'un veut tester la distribution de cette méthode: jsfiddle.net/F9UTG/1
ahren

8
@ JackFrost ouais, c'est vrai. Vous n'êtes pas stupide, vous apprenez juste :)
Ionuț G. Stan

3
Cette question est ancienne, mais comprendre cette réponse m'a pris trop de temps Oo, je pense que développer math.random sur la prochaine version JavaScript serait plutôt utile
Jonathan Ortega

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

19
Je sais que c'est une réponse TRÈS ancienne, mais l'utilisation (Math.random() * (maximum - minimum + 1) ) << 0est plus rapide.
Ismael Miguel

11
@IsmaelMiguel Utilisation des opérateurs binaires ( x << 0, x | 0, ~~x) au lieu de Math.floor()convertis xen un complément à deux avec beaucoup plus petite gamme que Number.MAX_SAFE_INTEGER(2³²⁻¹ vs 2⁵³), donc vous devez l' utiliser avec précaution!
le_m

@IsmaelMiguel Yo Je viens d'essayer votre méthode dans la console et j'ai obtenu aléatoirement une valeur négative! Math.randRange = (minimum, maximum) => (Math.random () * (maximum - minimum + 1)) << 0 Math.randRange (2,657348096152) -1407373159
bluejayke

@bluejayke Parce que 657348096152 (1001100100001100111111111111000010011000 en binaire) a 40 bits, tandis que l'arithmétique au niveau du bit utilise 32 bits. Si vous le faites, 657348096152|0vous obtenez 218099864 (1100111111111111000010011000 en binaire).
Ismael Miguel

1
Ceci est une réponse intelligente. Faire l'intervalle en interne [min, max + 1) permet en fait d'obtenir le résultat souhaité de [min, max] étant tous deux inclus. Je vous remercie! :)
Mladen B.15

135

Math.random ()

Renvoie un nombre aléatoire entier compris entre min ( inclus ) et max ( inclus ):

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

Ou tout nombre aléatoire compris entre min ( inclus ) et max ( non inclus ):

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

Exemples utiles (entiers):

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

** Et toujours agréable d'être rappelé (Mozilla):

Math.random () ne fournit pas de nombres aléatoires sécurisés cryptographiquement. Ne les utilisez pas pour tout ce qui concerne la sécurité. Utilisez plutôt l'API Web Crypto, et plus précisément la méthode window.crypto.getRandomValues ​​().


56
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 (empruntée à la programmation fonctionnelle) qui, lorsqu'elle est appelée, renverra un entier aléatoire entre les valeurs bottomet top, inclus. Nous disons «inclusif» parce que nous voulons inclure à la fois le bas et le haut dans la plage de numéros qui peuvent être retournés. De cette façon, getRandomizer( 1, 6 )renverra 1, 2, 3, 4, 5 ou 6.

(le bas est un nombre inférieur, le haut est un nombre supérieur)

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 topet bottom, nous obtiendrons un double quelque part entre 0et 1+b-a.

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

Math.floorarrondit le nombre à l'entier le plus proche. Nous avons donc maintenant tous les entiers entre 0et top-bottom. Le 1 semble déroutant, mais il doit être là parce que nous arrondissons toujours vers le bas, de sorte que le premier chiffre ne sera jamais atteint sans lui. La décimale aléatoire que nous générons doit être dans la plage 0de (1+top-bottom)sorte que nous puissions arrondir vers le bas et obtenir un entier dans la plage 0detop-bottom

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

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


REMARQUE: Si vous passez d'abord une valeur non entière ou le plus grand nombre, vous obtiendrez un comportement indésirable, mais à moins que quelqu'un ne le demande, je ne vais pas me plonger dans l'argument qui vérifie le code car il est assez loin de l'intention de la question d'origine .


1
Je me rends compte que c'est environ 2½ ans plus tard, mais avec les entrées 1 et 6, votre fonction renvoie les valeurs 1, 2, 3, 4 et 5, mais jamais un 6, comme si c'était "inclusif".
du

9
@some, ça pourrait être pire, j'ai 2 ans et demi + 1 jour plus tard ^^
ajax333221

+1, j'ai testé votre code, il semble créer une valeur correcte. Structure créative pour gérer des scénarios fixes qui pourraient être répétés beaucoup dans le code.
Chris

Pourquoi avez-vous une fonction dans une fonction pour cela?
Alph.Dev

1
@ Alph.Dev Pour découpler la logique qui utilise le générateur de nombres aléatoires de la logique qui décide exactement quelle distribution de nombres aléatoires utiliser. Lorsque le code qui utilise le générateur de nombres aléatoires l'accepte comme paramètre (une fonction à 0 argument qui renvoie toujours un nouveau nombre aléatoire), il peut fonctionner avec n'importe quelle sorte de générateur de nombres aléatoires.
Gordon Gustafson

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

Alternative si vous utilisez Underscore.js, vous pouvez utiliser

_.random(min, max)

1
Underscore fournit en fait une _.uniqueId()fonction que vous pouvez appeler pour les modèles côté client.
obfk

Utilisation des opérateurs binaires ( x << 0, x | 0, ~~x) au lieu de Math.floor()convertis xen un complément à deux avec une gamme beaucoup plus petite que Number.MAX_SAFE_INTEGER(2³²⁻¹ contre 2⁵³), donc vous devez l' utiliser avec précaution!
le_m

31

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

votre «entre» est-il inclusif ou exclusif? c'est-à-dire [1,10], [1,10), (1,10] ou (1,10)?
evandrix

1
C'est partiellement inclusif: [1, *)
Ivan Z

quel est le besoin de + 1 à la fin de la fonction? Cela fonctionne parfaitement, je suppose.
Shachi

18

Si vous avez besoin d'une variable entre 0 et max, vous pouvez utiliser:

Math.floor(Math.random() *  max);

Le max est-il inclusif ou exclusif>?
Tree

2
@Tree utilisant Math.floor max est exclusif. Si vous voulez que max soit inclusif, vous pouvez utiliser Math.round.
Luke

14

Les autres réponses ne tiennent pas compte des paramètres parfaitement raisonnables de 0et 1. Au lieu de cela, vous devez utiliser la round place de ceilou 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

1
Votre réponse est vraie mais je pense que votre exemple est faux. console.log(randomNumber(5,6)); # 9 6 6 5 7 7Les 9 et 7 se situent-ils entre 5 et 6? ...... vous devriez le corriger ou expliquer ..
Sachin

12

Voici l'implémentation MS DotNet de la classe Random en 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

La classe MS DotNet Random est sous la licence Ms-RSL , ce qui signifie qu'elle est protégée par des droits d'auteur. Soyez donc prudent lorsque vous utilisez ce code dérivé, car il peut constituer un terrain pour les cas de violation du droit d'auteur.
JohannesB

12

Utilisez cette fonction pour obtenir des nombres aléatoires entre une plage donnée

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

10

Après avoir généré un nombre aléatoire à l'aide d'un programme informatique, il est toujours considéré comme un nombre aléatoire si le numéro sélectionné est une partie ou le numéro complet du numéro initial. Mais s'il 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 une substance précieuse comme un programme de loterie ou un jeu de hasard, votre programme sera rejeté par la direction si vous n'êtes pas intéressé par le cas ci-dessus.

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

Générez un nombre aléatoire en utilisant Math.random(). (Dites ceci n)

Now for [0,10) ==>  n*10 (i.e. one digit) and for[10,100) ==> n*100 (i.e. 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. (i.e. get floor) - using Math.floor(), this can be done.

Si vous savez lire un tableau de nombres aléatoires pour choisir un nombre aléatoire, vous savez que le processus ci-dessus (multipliant par 1, 10, 100 et ainsi de suite) ne viole pas celui que j'ai mentionné au début (car il ne change que le place du point décimal.)

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

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

Laissez maintenant entrer dans votre rôle:

Vous avez demandé des chiffres parmi une plage spécifique. (Dans ce cas, vous êtes biaisé dans cette plage. - En prenant un nombre de [1,6] en lançant un dé, alors vous êtes biaisé en [1,6] mais c'est toujours un hasard si et seulement si le dé est sans biais .)

Considérez donc votre plage ==> [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 première méthode, j'ai d'abord créé un tableau qui contient les nombres dont vous avez besoin, puis je les ai placés au hasard dans un autre tableau. Dans la deuxième méthode, générez des nombres au hasard et vérifiez que ceux-ci sont dans la plage dont vous avez besoin. Mettez-le ensuite dans un tableau. Ici, j'ai généré deux nombres aléatoires et utilisé le total d'entre eux 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 un certain biais. Je recommanderais donc ma première méthode pour générer des nombres aléatoires dans une plage spécifique.

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


3
"aléatoire" ne signifie pas nécessairement "uniformément distribué". "biaisé" n'implique pas "non aléatoire". des moyennes aléatoires tirées d'une distribution de probabilité.
syzygy

6
Peut à peine dire ce que cette réponse essaie de dire. Cependant, si vous avez besoin de nombres aléatoires pour des utilisations comme les numéros de loterie et les jeux de hasard. D'abord, vous ne devriez probablement pas les générer sur le client. Deuxièmement, vous avez besoin d'un générateur de nombres aléatoires cryptographiquement sécurisé et l'algo fourni n'est pas suffisant. L'appel aléatoire à plusieurs reprises ne rend pas le résultat "plus aléatoire". L'auteur semble être préoccupé par les biais, mais ne fournit pas un bon algo pour les empêcher. En fait, les autres réponses courtes fournies produisent des nombres aléatoires non biaisés (en supposant que le générateur aléatoire sous-jacent est non biaisé).
Jeff Walker Code Ranger du

@JeffWalkerCodeRanger Je pense que ce qu'il voulait dire, c'est qu'avec l'algorithme "normal" [c'est-à-dire Math.floor(Math.random() * (6 - 1 + 1) + 1)] les nombres 1 et 6 seront nécessairement roulés moins de fois que 2, 3, 4 et 5. Cependant, la différence est fondamentalement insignifiante.
oldboy

10

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

8
function getRandomInt(lower, upper)
{
    //to create an even sample distribution
    return Math.floor(lower + (Math.random() * (upper - lower + 1)));

    //to produce an uneven sample distribution
    //return Math.round(lower + (Math.random() * (upper - lower)));

    //to exclude the max value from the possible values
    //return Math.floor(lower + (Math.random() * (upper - lower)));
}

Pour tester cette fonction et les variantes de cette fonction, enregistrez le code HTML / JavaScript ci-dessous dans un fichier et ouvrez-le avec un navigateur. Le code produira un graphique montrant la distribution d'un million d'appels de fonction. Le code enregistrera également les cas de bord, donc si la fonction produit une valeur supérieure au max ou inférieure au min, vous.serez.savoir.environ.it.

<html>
    <head>
        <script type="text/javascript">
        function getRandomInt(lower, upper)
        {
            //to create an even sample distribution
            return Math.floor(lower + (Math.random() * (upper - lower + 1)));

            //to produce an uneven sample distribution
            //return Math.round(lower + (Math.random() * (upper - lower)));

            //to exclude the max value from the possible values
            //return Math.floor(lower + (Math.random() * (upper - lower)));
        }

        var min = -5;
        var max = 5;

        var array = new Array();

        for(var i = 0; i <= (max - min) + 2; i++) {
          array.push(0);
        }

        for(var i = 0; i < 1000000; i++) {
            var random = getRandomInt(min, max);
            array[random - min + 1]++;
        }

        var maxSample = 0;
        for(var i = 0; i < max - min; i++) {
            maxSample = Math.max(maxSample, array[i]);
        }

        //create a bar graph to show the sample distribution
        var maxHeight = 500;
        for(var i = 0; i <= (max - min) + 2; i++) {
            var sampleHeight = (array[i]/maxSample) * maxHeight;

            document.write('<span style="display:inline-block;color:'+(sampleHeight == 0 ? 'black' : 'white')+';background-color:black;height:'+sampleHeight+'px">&nbsp;[' + (i + min - 1) + ']:&nbsp;'+array[i]+'</span>&nbsp;&nbsp;');
        }
        document.write('<hr/>');
        </script>
    </head>
    <body>

    </body>
</html>

7

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

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

Cela multiplie un nombre aléatoire par 6, puis y ajoute 0,5. Arrondissez ensuite le nombre à un entier positif en faisant:

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

Ceci arrondit le nombre au nombre entier le plus proche.

Ou pour le 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 pour laquelle vous supprimez 0,5 de la valeur minimale est que l'utilisation de la valeur minimale seule vous permettrait d'obtenir un entier supérieur de un à votre valeur maximale. En supprimant 0,5 de la valeur minimale, vous empêchez essentiellement la valeur maximale d'être arrondie.

J'espère que cela pourra aider.


Si vous excluez 0 , cela n'a aucun sens , il n'est donc pas nécessaire d'arrondir la plage de 0 à 0,5.
ILMostro_7

7

En utilisant le code suivant, vous pouvez générer un tableau de nombres aléatoires, sans répétition, 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. i.e 4
            // max(inclusive) : maximun value of a range. it must be any positive integer. i.e 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;
        }

7

Je sais que cette question a déjà reçu une réponse, mais ma réponse pourrait aider quelqu'un.

J'ai trouvé cette méthode simple sur W3Schools:

Math.floor((Math.random() * max) + min);

J'espère que cela aiderait quelqu'un.


1
Math.floor ((Math.random () * 1) + 0); donne toujours 0
madprops

1
@madprops Parce que le nombre maximum est exclusif. Pour obtenir 0 ou 1, vous devez définir 2 comme nombre maximum.
NutCracker

1
ou vous ajoutez simplement + 1 dans la fonction qui appelle cette méthode
Pietro Coelho

6

Nombre entier aléatoire entre le plus bas et le plus haut:

function randomRange(l,h){
  var range = (h-l);
  var random = Math.floor(Math.random()*range);
  if (random === 0){random+=1;}
  return l+random;
}

Pas la solution la plus élégante .. mais quelque chose de rapide.


5

Voici ce que j'utilise pour générer des nombres aléatoires.

function random(high,low) {
    high++;
    return Math.floor((Math.random())*(high-low))+low;
}

Nous exécutons high++parce que Math.random()génère un nombre aléatoire entre 0, (inclus) et 1 (exclusif) Celui qui est exclu, signifie que nous devons augmenter le plus haut de un avant d'exécuter tout calcul. Nous soustrayons ensuite le bas du haut, ce qui nous donne le nombre le plus élevé à générer - bas, puis + bas, ramenant le haut à la normale et faisant le plus petit nombre au moins bas. puis nous retournons le nombre résultant

random(7,3) pourrait revenir 3,4,5,6, or 7


2
Comme il highn'est utilisé qu'une seule fois, vous pouvez également utiliser high-low+1plutôt que d'avoir l'instruction d'incrémentation distincte. De plus, la plupart des utilisateurs s'attendent à ce que le lowparamètre vienne en premier.
Chris Walsh

4
    <!DOCTYPE html>
<html>
    <head>
            <meta charset="utf-8" />
    </head>
    <body>
        <script>
            /*

                assuming that window.crypto.getRandomValues is available
                the real range would be fron 0 to 1,998 instead of 0 to 2,000
                See javascript documentation for explanation
                https://developer.mozilla.org/en-US/docs/Web/API/RandomSource/getRandomValues
            */
            var array = new Uint8Array(2);
            window.crypto.getRandomValues(array);
            console.log(array[0] + array[1]);

        </script>
    </body>
</html>

Uint8Array crée un tableau rempli d'un nombre jusqu'à 3 chiffres qui serait un maximum de 999. Ce code est très court.


4

Voici un exemple de fonction javascript qui peut générer un nombre aléatoire de n'importe quelle longueur spécifiée sans utiliser Math.random ():

    function genRandom(length)
    {
     const t1 = new Date().getMilliseconds();
     var min = "1",max = "9";
     var result;
     var numLength = length;
     if (numLength != 0)
     {
        for (var i = 1; i < numLength; i++)
        {
           min = min.toString() + "0";
           max = max.toString() + "9";
        }
     } 
     else
     {
        min = 0;
        max = 0;
        return; 
     }

      for (var i = min; i <= max; i++)
      {
           //Empty Loop
      }

      const t2 = new Date().getMilliseconds();
      console.log(t2);
      result = ((max - min)*t1)/t2;
      console.log(result);
      return result;
    }

t1 / t2 toujours très proche de 1. et donc votre fonction retourne le même nombre lorsque la fonction est appelée de manière répétitive .. jsbin.com/xogufacera/edit?js,console
Sunil BN

vérifiez l'url jsbin .. vous verrez la sortie vous
Sunil BN

Cela fonctionne très bien lorsque la longueur est comprise entre 4 et 10 (comme je l'ai testé sur ma machine), car les valeurs des constantes T1 et T2 doivent avoir une distance appropriée.
Nilesh Pawar

3

c'est mon point de vue sur un nombre aléatoire dans une plage, comme dans je voulais obtenir un nombre aléatoire dans une plage de base à exposant. par exemple base = 10, exposant = 2, donne un nombre aléatoire de 0 à 100, idéalement, etc.

si cela permet de l'utiliser, le voici:

// get random number within provided base + exponent
// by Goran Biljetina --> 2012

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}
var numSeq = new Array();
function add(num,seq){
    var toAdd = new Object();
     toAdd.num = num;
     toAdd.seq = seq;
     numSeq[numSeq.length] = toAdd;
}
function fillNumSeq (num,seq){
    var n;
    for(i=0;i<=seq;i++){
        n = Math.pow(num,i);
        add(n,i);
    }
}
function getRandNum(base,exp){
    if (isEmpty(base)){
        console.log("Specify value for base parameter");
    }
    if (isEmpty(exp)){
        console.log("Specify value for exponent parameter");
    }
    fillNumSeq(base,exp);
    var emax;
    var eseq;
    var nseed;
    var nspan;
    emax = (numSeq.length);
    eseq = Math.floor(Math.random()*emax)+1;
    nseed = numSeq[eseq].num;
    nspan = Math.floor((Math.random())*(Math.random()*nseed))+1;
    return Math.floor(Math.random()*nspan)+1;
}

console.log(getRandNum(10,20),numSeq);
//testing:
//getRandNum(-10,20);
//console.log(getRandNum(-10,20),numSeq);
//console.log(numSeq);

3

Math.random() est rapide et convient à de nombreuses fins, mais ce n'est pas approprié si vous avez besoin de valeurs sécurisées sur le plan cryptographique (ce n'est pas sécurisé), ou si vous avez besoin d'entiers d'une distribution sans biais complètement uniforme (l'approche de multiplication utilisée dans d'autres réponses produit certaines valeurs un peu 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 toutes les valeurs générées que nous ne pouvons pas mapper uniformément dans la plage cible. Ce sera plus lent, mais il ne devrait être significatif que si vous générez un nombre extrêmement élevé de valeurs.

Pour clarifier le problème de distribution biaisée, considérons le cas où nous voulons générer une valeur entre 1 et 5, mais nous avons un générateur de nombres aléatoires qui produit des valeurs entre 1 et 16 (une valeur de 4 bits). Nous voulons avoir le même nombre de valeurs générées correspondant à chaque valeur de sortie, mais 16 ne se divise pas également par 5: il reste un reste de 1. Nous devons donc rejeter 1 des valeurs générées possibles et continuer uniquement lorsque nous obtenons l'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 commun pouvant être représentée par le numbertype standard de JavaScript . (Cela peut être modifié pour utiliser BigInts si vous avez besoin d'une plus grande plage.) Quelle que soit la plage choisie, la fraction des valeurs générées qui sont rejetées sera toujours inférieure à 0,5, donc le nombre attendu de rejets sera toujours inférieur à 1,0 et généralement proche de 0,0; vous n'avez pas à vous en préoccuper en 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]



1

Vous pouvez vous cet extrait de code,

let randomNumber = function(first,second){
let number = Math.floor(Math.random()*Math.floor(second));
while(number<first){

    number = Math.floor(Math.random()*Math.floor(second));
}
return number;
}

1
Il y a une ligne dupliquée inutile ici. Utilisez simplement à la do - whileplace dewhile
Javi Marzán

1

Ionuț G. Stan a écrit une excellente réponse, mais elle était un peu trop complexe à comprendre. J'ai donc trouvé une explication encore plus simple des mêmes concepts sur https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation par Jason Anello.

REMARQUE: La seule chose importante que vous devez savoir avant de lire l'explication de Jason est une définition de "tronquer". Il utilise ce terme pour décrire Math.floor(). Le dictionnaire Oxford définit "tronquer" comme:

Raccourcissez (quelque chose) en coupant le haut ou l'extrémité.


0

Cela peut gérer la génération d'un nombre aléatoire UNIQUE jusqu'à 20 chiffres

JS

var generatedNumbers = [];

function generateRandomNumber(precision) { // precision --> number precision in integer 
    if (precision <= 20) {
        var randomNum = Math.round(Math.random().toFixed(precision) * Math.pow(10, precision));
        if (generatedNumbers.indexOf(randomNum) > -1) {
            if (generatedNumbers.length == Math.pow(10, precision))
                return "Generated all values with this precision";
                return generateRandomNumber(precision);
        } else {
            generatedNumbers.push(randomNum);
            return randomNum;
        }
    } else
       return "Number Precision shoould not exceed 20";
}
generateRandomNumber(1);

entrez la description de l'image ici

JsFiddle


Je vote pour cela juste parce que.
Taylor Ackley

1
@TaylorAckley Cette réponse ne répond pas à la question.
RomainValeri

0

/ * Écrire une fonction appelée randUpToqui accepte un nombre et renvoie un nombre entier aléatoire entre 0 et ce nombre? * /

var randUpTo = function(num) {
    return Math.floor(Math.random() * (num - 1) + 0);
};

/ * Écrivez une fonction appelée randBetweenqui accepte deux nombres représentant une plage et renvoie un nombre entier aléatoire entre ces deux nombres. * /

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

/ * Écrire une fonction appelée randFromTillqui accepte deux nombres représentant une plage et renvoie un nombre aléatoire entre min (inclus) et max (exclusif). * /

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

/ * Écrire une fonction appelée randFromToqui accepte deux nombres représentant une plage et renvoie un entier aléatoire entre min (inclus) et max (inclus) * /

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

1
Magnifique, pourriez-vous également noter que randBetween est (exclusif) (exclusif)?
pfdint

0

J'ai fait cette fonction qui prend en compte des options comme min, max, exclude (une liste d'entiers à exclure) et seed (au cas où vous voudriez un générateur aléatoire prédéfini).

get_random_int = function(args={})
{
    let def_args =
    {
        min: 0,
        max: 1,
        exclude: false,
        seed: Math.random
    }

    args = Object.assign(def_args, args)

    let num = Math.floor(args.seed() * (args.max - args.min + 1) + args.min)

    if(args.exclude)
    {
        let diff = args.max - args.min
        let n = num

        for(let i=0; i<diff*2; i++)
        {
            if(args.exclude.includes(n))
            {
                if(n + 1 <= args.max)
                {
                    n += 1
                }

                else
                {
                    n = args.min
                }
            }

            else
            {
                num = n
                break
            }
        }
    }

    return num
}

Il peut être utilisé comme:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1,
        exclude: [3, 6, 5],
        seed: my_seed_function
    }
)

Ou plus simplement:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1
    }
)

Ensuite, vous pouvez faire:

let item = some_list[n]

Gist: https://gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e


0
  • random (min, max) génère un nombre aléatoire entre min (inclus) et max (exclusif)
  • Math.floor arrondit un nombre à l'entier le plus proche

    function generateRandomInteger (min, max) { 
        return Math.floor(random(min,max)) 
    }`

Donc, pour générer un entier aléatoire entre 4 et 8 inclus, appelez la fonction ci-dessus avec les arguments suivants:

generateRandomInteger (4,9)

0

Ma méthode pour générer un nombre aléatoire entre 0 et n, où n <= 10 (n exclu):

Math.floor((Math.random() * 10) % n)
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.