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

"151930920 des Mathématiques".random()

From the Mozilla Developer Network documentation:

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

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

utilisation:

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

ventilation:

nous retournons une fonction (empruntant de la programmation fonctionnelle) qui, lorsqu'elle est appelée , retournera un entier aléatoire entre les valeurs bottom et top , inclusivement. Nous disons "inclusif" parce que nous voulons inclure à la fois le bas et le haut dans la gamme des nombres qui peuvent être retournés. De cette façon, getRandomizer( 1, 6 ) retournera soit 1, 2, 3, 4, 5, ou 6.

(nombre inférieur, 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 top et bottom , nous obtiendrons un double quelque part entre 0 et 1+b-a .

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

Math.floor arrondit le nombre à l'entier le plus proche. Donc nous avons maintenant tous les nombres entiers entre 0 et top-bottom . Le 1 semble confus, mais il doit être là parce que nous sommes toujours en train d'arrondir vers le bas, de sorte que le chiffre supérieur ne sera jamais atteint sans lui. La décimale aléatoire que nous générons doit être dans la gamme 0 à (1+top-bottom) pour que nous puissions arrondir et obtenir un int dans la gamme 0 à top-bottom

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

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

NOTE: Si vous passez dans une valeur non-entière ou le plus grand nombre d'abord vous obtiendrez un comportement indésirable, mais à moins que quelqu'un le demande Je ne vais pas plonger dans le code de vérification d'argument comme son assez loin de l'intention de la question originale.

retourner un nombre aléatoire entre 1 et 10:

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

retourner un nombre aléatoire entre 1 et 100:

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

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

Alternative si vous utilisez Underscore.js vous pouvez utiliser

_.random(min, max)

les autres réponses ne tiennent pas compte des paramètres parfaitement raisonnables de 0 et 1 . Au lieu de cela, vous devez utiliser le round à la place de de ceil ou 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 la génération d'un nombre aléatoire à l'aide d'un programme informatique, il est toujours à considérer comme un nombre aléatoire si le nombre choisi est une partie ou l'intégralité de la première. Mais si elle a été changée, alors mathématiciens ne sont pas accepter comme un nombre aléatoire et ils peuvent 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 êtes l'élaboration d'un programme pour générer un nombre aléatoire pour un choses précieuses telles que le programme de loterie, ou jeu de jeu, puis votre programme sera rejeté par la direction si vous n'êtes pas considérer au sujet du cas ci-dessus.

alors pour ce genre de personnes, voici ma suggestion:

génère un nombre aléatoire en utilisant Math.random() .(dis 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 comment lire la table de nombres aléatoires pour choisir un nombre aléatoire, vous savez processus ci-dessus (en multipliant par 1, 10, 100 et ainsi de suite) ne viole pas celui que j'ai mentionné au début.( Parce qu'il ne change que la place de la virgule.)

étudiez 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 besoin [0,99] puis le plancher de n*100 est votre réponse et ainsi de suite.

maintenant laissez entrer dans votre rôle:

vous avez demandé des nombres parmi les spécifiques gamme. (Dans ce cas, vous êtes biaisé parmi cette gamme. - En prenant un nombre de [1,6] par rouleau une matrice, alors vous êtes biaisé dans [1,6] mais il est tout de même un aléatoire si et seulement si la matrice est impartiale.)

donc considérez votre gamme = = > [78, 247] nombre d'éléments de la gamme = 247 - 78 + 1 = 170; (puisque les frontières sont inclus.

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

Note: dans la première méthode, j'ai d'abord créé un tableau qui contient des nombres dont vous avez besoin et puis mis au hasard dans un autre tableau. Dans la méthode deux, générer des nombres au hasard et vérifier ceux sont dans la gamme dont vous avez besoin. Puis le mettre dans un tableau. Ici, j'ai généré deux nombres aléatoires et utilisé d'entre eux afin de maximiser la vitesse du programme en réduisant le taux d'échec que l'obtention d'un utile. Cependant, ajouter des nombres générés donnera aussi une certaine biassness. Je recommande 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 en 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;
}

Voici la mise en œuvre de MS DotNet de Random class 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

si vous avez besoin de variable entre 0 et max vous pouvez utiliser:

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

pour obtenir un nombre aléatoire dire entre 1 et 6, d'abord faire:

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

cela multiplie un nombre aléatoire par 6 et y ajoute 0,5. Prochain tour le nombre entier positif en faisant:

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

ce chiffre est arrondi au nombre entier le plus proche.

ou pour le rendre plus compréhensible faites ceci:

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

en général, le code pour faire cela 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 enlever 0.5 de la valeur minimale est que l'utilisation de la valeur minimale seule vous permettrait d'obtenir un entier qui était un de plus que votre valeur maximale. En enlevant 0,5 de la valeur minimale, vous empêchez essentiellement la valeur maximale d'être arrondie vers le haut.

Espère que ça aide.

en utilisant le code suivant, vous pouvez générer un tableau de nombres aléatoires, sans répétition, dans un intervalle donné.

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

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.

je sais que cette question est déjà répondu 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 ça aidera quelqu'un.

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(exclu) celui qui est exclu, signifie que nous devons augmenter le maximum par un avant d'exécuter n'importe quel calcul. Nous soustrayons alors le faible du haut, nous donnant le nombre le plus élevé à générer - faible, puis +faible, ramenant le haut à la normale, et faisant le nombre le plus bas atleast bas. ensuite, nous reviendrons sur l' nombre résultant

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

    <!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éer un tableau rempli d'un nombre jusqu'à 3 chiffres qui serait un maximum de 999. Ce code est très court.

c'est mon avis sur un nombre aléatoire dans une gamme, comme dans je voulais obtenir un nombre aléatoire dans une gamme de base à exposant. par exemple base = 10, Exposant = 2, donne un nombre aléatoire de 0 à 100, idéalement, et ainsi de suite.

si elle aide à l'utiliser, la 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);

Hé les gars, j'ai créé une fonction javascript identique à Math.random() à l'aide de laquelle nous pouvons générer nombre aléatoire de n'importe quelle longueur spécifiée . Sans utiliser de Math.fonction aléatoire .

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

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 ses variantes, sauvegardez le HTML/JavaScript ci-dessous dans un fichier et ouvrez-le avec un navigateur. Le code produira un" graphe 151930920 ""graphe 151940920" montrant la distribution d'un million d'appels de fonction. Le code enregistrera aussi les cas de bord, donc si la fonction produit une valeur supérieure au max, ou inférieure au min, vous.will.je sais.A propos.ça.

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

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

cela permet de générer jusqu'à 20 chiffres de nombre aléatoire UNIQUE

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

JsFiddle

/* Ecrire une fonction appelée randUpTo qui accepte un nombre et renvoie un un nombre entier entre 0 et ce nombre? * /

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

/* Écrire une fonction appelée randBetween qui accepte deux nombres représentant un éventail et renvoie un nombre entier aléatoire entre ces deux nombre. * /

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

/* Écrire une fonction appelée randFromTill qui accepte deux nombres représentant une gamme et retourne un aléatoire nombre entre min (inclusive) et max (exclusif). * /

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

/* Écrire une fonction appelée randFromTo qui accepte deux nombres représente une gamme et renvoie un entier aléatoire entre min (inclus) et max (inclusive) * /

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

Alternative Solution: -

let makeGuess = function(guess){
    let min = 1;
    let max = 5;   
    let randomNumber = Math.floor(Math.random() * (max - min + 1)) + min

    return guess === randomNumber;

}
console.log(makeGuess(1));

je me suis demandé comment la distribution après assez de passages serait pour une telle fonction aléatoire.

et aussi de vérifier si cette distribution serait plus ou moins la même dans les différents navigateurs.

donc voici un extrait à exécuter. Les nombres peuvent être changés avant d'appuyer sur le bouton.

function getRandomNumberInRange(Min, Max) {
    return Math.floor(Math.random() * (Max - Min + 1)) + Min;
}

function printDictAsTable(dict){
   let htmlstr = "<table border=1><tr><th>Number</th><th>Count</th></tr>";
   
   let sortedKeys = Object.keys(dict).sort(function(a,b){return a-b});

   for (let i=0; i<sortedKeys.length; i++) {
     let key = sortedKeys[i];
     htmlstr += "<tr><td>"+ key +" </td><td>" + dict[key] + " </td></tr>";
   }
   htmlstr += "</table>";
   document.getElementById("tableContainer").innerHTML = htmlstr;
}

function loopRandomAndPrint(){
    let min = Number(document.getElementById("randomMinLimit").value);
    let max = Number(document.getElementById("randomMaxLimit").value);
    if (max < min){let temp = max; max = min; min = temp;}
    let loopTotal = Number(document.getElementById("loopLimit").value);
    let dict = {};
    
    for(i = min; i <= max; ++i){
        dict[i] = 0;
    }

    for(i = 0; i < loopTotal; i++){
        let num = getRandomNumberInRange(min, max);
        dict[num] = dict[num] + 1;
    }
    
    printDictAsTable(dict);
}

loopRandomAndPrint();

<div id="topContainer">
<div id="inputAndButton" style="float: left;">
<p>Min  : <input type="number" id="randomMinLimit" value=4></p>
<p>Max  : <input type="number" id="randomMaxLimit" value=8></p>
<p>Loops: <input type="number" id="loopLimit" value=1000></p>
<button type="button" onclick="loopRandomAndPrint()">
Loop random function and show </button>
</div>
<div id="tableContainer" style="float: right;">
</div>
</div>