Come faccio a generare numeri interi casuali tra due variabili specificate in JavaScript, ad esempio, x = 4e y = 8l'uscita farebbe qualsiasi 4, 5, 6, 7, 8?

Ci sono alcuni esempi nella pagina Rete di sviluppatori Mozilla :

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

Ecco la logica dietro di esso. È una semplice regola di tre:

Math.random()restituisce un valore Numbercompreso tra 0 (incluso) e 1 (esclusivo). Quindi abbiamo un intervallo come questo:

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

Ora vorremmo un numero compreso tra min(incluso) e max(esclusivo):

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

Possiamo usare il Math.randomper ottenere il corrispondente nell'intervallo [min, max). Ma prima dovremmo considerare un po 'il problema sottraendo mindal secondo intervallo:

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

Questo da:

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

Ora possiamo applicare Math.randome quindi calcolare il corrispondente. Scegliamo un numero casuale:

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

Quindi, per trovare x, dovremmo fare:

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

Non dimenticare di aggiungere di minnuovo, in modo da ottenere un numero nell'intervallo [min, max):

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

Questa è stata la prima funzione di MDN. Il secondo, restituisce un numero intero compreso tra minemax , entrambi inclusi.

Ora per ottenere numeri interi, puoi usare round, ceilo floor.

È possibile utilizzare Math.round(Math.random() * (max - min)) + min, ciò tuttavia fornisce una distribuzione non uniforme. Entrambi, mine maxhanno solo circa la metà delle possibilità di tirare:

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

Se maxescluso dall'intervallo, ha ancora meno possibilità di tirare rispetto min.

Con Math.floor(Math.random() * (max - min +1)) + minte hai una distribuzione perfettamente uniforme.

min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval)
|        |        |         |        |        |
└───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘   ← Math.floor()
   min     min+1               max-1    max

Non puoi usare ceil()e -1in quella equazione perché maxora aveva un po 'meno possibilità di tirare, ma puoi anche ottenere il risultato (indesiderato) min-1.

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

Math.random ()

Restituisce un numero casuale intero compreso tra min ( incluso ) e max ( incluso ):

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

O qualsiasi numero casuale tra min ( incluso ) e max ( non incluso ):

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

Esempi utili (numeri interi):

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

** E sempre bello da ricordare (Mozilla):

Math.random () non fornisce numeri casuali crittograficamente sicuri. Non utilizzarli per nulla relativi alla sicurezza. Utilizzare invece l'API Web Crypto e, più precisamente, il metodo window.crypto.getRandomValues ​​().

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

utilizzo:

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

abbattersi:

Stiamo restituendo una funzione (prendendo in prestito dalla programmazione funzionale) che quando viene chiamata, restituirà un numero intero casuale tra i valori bottome top, incluso. Diciamo "inclusivo" perché vogliamo includere sia la parte inferiore che la parte superiore nell'intervallo di numeri che possono essere restituiti. Per di qua,getRandomizer( 1, 6 ) restituirà 1, 2, 3, 4, 5 o 6.

(in basso c'è un numero più basso, in alto è un numero maggiore)

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

Math.random()restituisce un doppio casuale tra 0 e 1 e se lo moltiplichiamo per uno più la differenza tra tope bottom, otterremo un doppio tra 0e 1+b-a.

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

Math.floorarrotonda il numero per difetto all'intero più vicino. Quindi ora abbiamo tutti i numeri interi tra 0e top-bottom. L'1 sembra confuso, ma deve essere lì perché stiamo sempre arrotondando per difetto, quindi il numero più alto non sarà mai effettivamente raggiunto senza di esso. Il decimale casuale che generiamo ha bisogno di essere nel range 0di (1+top-bottom)modo che possiamo arrotondare verso il basso e ottenere un int nella gamma 0ditop-bottom

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

Il codice nell'esempio precedente ci ha fornito un numero intero nell'intervallo 0e top-bottom, quindi tutto ciò che dobbiamo fare ora è aggiungere bottoma quel risultato per ottenere un numero intero nell'intervallo bottome topcompreso. : D

NOTA: se passi prima un valore non intero o il numero maggiore, otterrai un comportamento indesiderato, ma a meno che qualcuno non lo richieda non approfondirò l'argomento controllando il codice come piuttosto lontano dall'intento della domanda originale .

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

Alternativa se stai usando Underscore.js che puoi usare

_.random(min, max)

Restituisce un numero casuale compreso tra 1 e 10:

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

Restituisce un numero casuale compreso tra 1 e 100:

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

Se hai bisogno di una variabile tra 0 e max puoi usare:

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

Le altre risposte non tengono conto dei parametri perfettamente ragionevoli di 0e 1. Invece dovresti usare round invece di ceilo 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

Ecco l'implementazione MS DotNet della classe casuale in 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;
}());

Uso:

        var r = new Random();
        var nextInt = r.Next(1, 100); //returns an integer between range
        var nextDbl = r.NextDouble(); //returns a random decimal

Utilizzare questa funzione per ottenere numeri casuali tra un determinato intervallo

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

Dopo aver generato un numero casuale utilizzando un programma per computer, viene comunque considerato un numero casuale se il numero selezionato è una parte o quella completa di quella iniziale. Ma se è stato modificato, i matematici non lo accettano come un numero casuale e possono chiamarlo un numero parziale. Ma se stai sviluppando un programma per un compito semplice, questo non sarà un caso da considerare. Ma se stai sviluppando un programma per generare un numero casuale per oggetti preziosi come un programma di lotteria o un gioco d'azzardo, il tuo programma verrà rifiutato dalla direzione se non prendi in considerazione il caso di cui sopra.

Quindi per quel tipo di persone, ecco il mio suggerimento:

Genera un numero casuale usando Math.random()(dillo 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.

Se sai come leggere la tabella dei numeri casuali per scegliere un numero casuale, sai che il processo sopra (moltiplicando per 1, 10, 100 e così via) non viola quello che sono stato menzionato all'inizio. (Perché cambia solo il luogo del punto decimale.)

Studia il seguente esempio e sviluppalo in base alle tue esigenze.

Se hai bisogno di un campione [0,9] allora floor of n * 10 è la tua risposta e se serve [0,99] allora floor of n * 100 è la tua risposta e così via.

Ora entra nel tuo ruolo:

Hai chiesto numeri tra intervalli specifici. (In questo caso sei influenzato da quell'intervallo. - Prendendo un numero da [1,6] tirando un dado, allora sei influenzato da [1,6] ma è comunque casuale se e solo se il dado è imparziale .)

Quindi considera il tuo intervallo ==> [78, 247] numero di elementi dell'intervallo = 247 - 78 + 1 = 170; (poiché entrambi i confini sono inclusivi.

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

Nota: nel metodo uno, prima ho creato un array che contiene numeri necessari e quindi li ho inseriti casualmente in un altro array. Nel secondo metodo, genera numeri in modo casuale e verifica che siano nell'intervallo di cui hai bisogno. Quindi inseriscilo in un array. Qui ho generato due numeri casuali e ne ho usati in totale per massimizzare la velocità del programma minimizzando il tasso di fallimento che ha ottenuto un numero utile. Tuttavia, l'aggiunta di numeri generati darà anche un po 'di biasimo. Quindi consiglierei il mio primo metodo per generare numeri casuali all'interno di un intervallo specifico.

In entrambi i metodi, la tua console mostrerà il risultato (premi F12 in Chrome per aprire la console)

Per un numero intero casuale con un intervallo, prova:

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

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

Per testare questa funzione e le varianti di questa funzione, salvare il codice HTML / JavaScript seguente in un file e aprirlo con un browser. Il codice produrrà un grafico che mostra la distribuzione di un milione di chiamate di funzione. Il codice registrerà anche i casi limite, quindi se la funzione produce un valore maggiore del massimo o inferiore al minimo, you.will.know.about.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>

Per ottenere un numero casuale dire tra 1 e 6, prima fai:

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

Questo moltiplica un numero casuale per 6 e quindi aggiunge 0,5 ad esso. Quindi arrotondare il numero a un numero intero positivo eseguendo:

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

Questo arrotondare il numero al numero intero più vicino.

O per renderlo più comprensibile fai questo:

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

In generale, il codice per farlo utilizzando le variabili è:

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

Il motivo per cui è stato rimosso 0,5 dal valore minimo è perché l'utilizzo del valore minimo da solo consentirebbe di ottenere un numero intero superiore al valore massimo. Eliminando 0,5 dal valore minimo, si impedisce essenzialmente di arrotondare il valore massimo.

Spero che aiuti.

Utilizzando il seguente codice è possibile generare array di numeri casuali, senza ripetere, in un determinato intervallo.

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

So che questa domanda ha già una risposta, ma la mia risposta potrebbe aiutare qualcuno.

Ho trovato questo semplice metodo su W3Schools:

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

Spero che questo possa aiutare qualcuno.

Numero intero casuale tra il più basso e il più alto:

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

Non la soluzione più elegante .. ma qualcosa di veloce.

Ecco cosa uso per generare numeri casuali.

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

Eseguiamo high++perchéMath.random() genera un numero casuale compreso tra 0, (incluso) e 1 (esclusivo). L'uno escluso significa che dobbiamo aumentare il livello di uno prima di eseguire qualsiasi calcolo. Quindi sottraggiamo il minimo dal massimo, dandoci il numero più alto da generare - basso, quindi + basso, riportando il ritorno alla normalità e rendendo minimo il numero più basso. quindi restituiamo il numero risultante

random(7,3) potrebbe tornare 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 crea un array riempito con un numero massimo di 3 cifre che sarebbe un massimo di 999. Questo codice è molto breve.

Ecco un esempio di una funzione javascript che può generare un numero casuale di qualsiasi lunghezza specificata senza usare 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;
    }

questa è la mia opinione su un numero casuale in un intervallo, poiché volevo ottenere un numero casuale in un intervallo di base da esponente. ad esempio base = 10, esponente = 2, fornisce un numero casuale compreso tra 0 e 100, idealmente e così via.

se aiuta a usarlo, eccolo qui:

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

Math.random() è veloce e adatto a molti scopi, ma non è appropriato se hai bisogno di valori crittograficamente sicuri (non è sicuro) o se hai bisogno di numeri interi da una distribuzione imparziale completamente uniforme (l'approccio di moltiplicazione utilizzato nelle altre risposte produce alcuni valori leggermente più spesso di altri).

In tali casi, possiamo usare crypto.getRandomValues() per generare numeri interi sicuri e rifiutare qualsiasi valore generato che non possiamo mappare uniformemente nell'intervallo target. Questo sarà più lento, ma non dovrebbe essere significativo se non stai generando un numero estremamente elevato di valori.

Per chiarire la preoccupazione di distribuzione distorta, considera il caso in cui vogliamo generare un valore compreso tra 1 e 5, ma abbiamo un generatore di numeri casuali che produce valori compresi tra 1 e 16 (un valore a 4 bit). Vogliamo avere lo stesso numero di valori generati associati a ciascun valore di output, ma 16 non si divide uniformemente per 5: lascia un resto di 1. Quindi dobbiamo rifiutare 1 dei possibili valori generati e continuare solo quando otteniamo uno dei 15 valori minori che possono essere uniformemente mappati nel nostro intervallo target. Il nostro comportamento potrebbe apparire come questo pseudocodice:

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.

Il codice seguente utilizza una logica simile, ma genera invece un numero intero a 32 bit, poiché si tratta della dimensione intera comune più grande che può essere rappresentata dal numbertipo standard di JavaScript . (Questo potrebbe essere modificato per usare BigInts se hai bisogno di un intervallo più ampio.) Indipendentemente dall'intervallo scelto, la frazione dei valori generati che vengono rifiutati sarà sempre inferiore a 0,5, quindi il numero atteso di rifiuti sarà sempre inferiore a 1,0 e di solito vicino a 0,0; non devi preoccuparti che rimanga in loop per sempre.

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]

Crypto-Strong

Per ottenere un numero intero casuale cripto-forte in ragne [x, y] provare

let cs= (x,y)=>x+(y-x+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0

console.log(cs(4,8))

Puoi questo frammento di codice,

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

Ionuț G. Stan ha scritto un'ottima risposta, ma era un po 'troppo complesso per me da capire. Quindi, ho trovato una spiegazione ancora più semplice degli stessi concetti su https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation di Jason Anello.

NOTA: l'unica cosa importante che dovresti sapere prima di leggere la spiegazione di Jason è una definizione di "troncato". Usa quel termine per descrivere Math.floor(). Il dizionario di Oxford definisce "troncato" come:

Accorcia (qualcosa) tagliando la parte superiore o finale.

Questo può gestire la generazione di un numero casuale UNICO fino a 20 cifre

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

/ * Scrivi una funzione chiamata randUpToche accetta un numero e restituisce un numero intero casuale compreso tra 0 e quel numero? * /

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

/ * Scrivi una funzione chiamata randBetweenche accetta due numeri che rappresentano un intervallo e restituisce un numero intero casuale tra questi due numeri. * /

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

/ * Scrivi una funzione chiamata randFromTillche accetta due numeri che rappresentano un intervallo e restituisce un numero casuale tra min (compreso) e max (esclusivo). * /

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

/ * Scrivi una funzione chiamata randFromToche accetta due numeri che rappresentano un intervallo e restituisce un numero intero casuale compreso tra min (inclusivo) e max (inclusivo) * /

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

Ho creato questa funzione che tiene conto di opzioni come min, max, exclude (un elenco di ints da escludere) e seed (nel caso in cui si desideri un generatore casuale con seeding).

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
}

Può essere usato come:

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

O più semplicemente:

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

Quindi puoi fare:

let item = some_list[n]

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

• random (min, max) genera un numero casuale tra min (compreso) e max (esclusivo)

• Math.floor arrotonda un numero per difetto all'intero più vicino

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

Quindi, per generare un numero intero casuale compreso tra 4 e 8 inclusi, chiama la funzione precedente con i seguenti argomenti:

generateRandomInteger (4,9)

Il mio metodo per generare un numero casuale compreso tra 0 e n, dove n <= 10 (n escluso):

Math.floor((Math.random() * 10) % n)