¿Cómo puedo generar números enteros aleatorios entre dos variables especificadas en JavaScript, por ejemplo, x = 4y y = 8generaría alguna 4, 5, 6, 7, 8?

Hay algunos ejemplos en la página 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;
}

Aquí está la lógica detrás de esto. Es una regla simple de tres:

Math.random()devuelve un valor Numberentre 0 (incluido) y 1 (exclusivo). Entonces tenemos un intervalo como este:

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

Ahora, nos gustaría un número entre min(inclusive) y max(exclusivo):

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

Podemos usar el Math.randompara obtener el correspondiente en el intervalo [min, max). Pero, primero debemos factorizar un poco el problema restando mindel segundo intervalo:

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

Esto da:

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

Ahora podemos aplicar Math.randomy luego calcular el corresponsal. Elija un número aleatorio:

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

Entonces, para encontrar x, haríamos:

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

No olvide minvolver a agregar , para que obtengamos un número en el intervalo [min, max):

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

Esa fue la primera función de MDN. El segundo, devuelve un número entero entre miny max, ambos inclusive.

Ahora para obtener enteros, puedes usar round, ceilo floor.

Podría usar Math.round(Math.random() * (max - min)) + min, sin embargo, esto proporciona una distribución no uniforme. Ambos, miny maxsolo tienen aproximadamente la mitad de posibilidades de rodar:

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

Con maxexcluidos del intervalo, tiene incluso menos posibilidades de rodar que min.

Con Math.floor(Math.random() * (max - min +1)) + minusted tiene una distribución perfectamente uniforme.

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

No puede usar ceil()y -1en esa ecuación porque maxahora tenía una probabilidad ligeramente menor de rodar, pero también puede rodar el resultado (no deseado) min-1.

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

Math.random ()

Devuelve un número aleatorio entero entre min ( incluido ) y max ( incluido ):

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

O cualquier número aleatorio entre min ( incluido ) y max ( no incluido ):

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

Ejemplos útiles (enteros):

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

** Y siempre es bueno recordarlo (Mozilla):

Math.random () no proporciona números aleatorios criptográficamente seguros. No los use para nada relacionado con la seguridad. Utilice la API de cifrado web en su lugar y, más precisamente, el método window.crypto.getRandomValues ​​().

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

uso:

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

Descompostura:

Estamos devolviendo una función (tomando prestada de la programación funcional) que cuando se llama, devolverá un número entero aleatorio entre los valores bottome topinclusive. Decimos "inclusivo" porque queremos incluir tanto los de abajo como los de arriba en el rango de números que se pueden devolver. De esta manera, getRandomizer( 1, 6 )devolverá 1, 2, 3, 4, 5 o 6.

(la parte inferior es el número inferior, la superior es el número mayor)

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

Math.random()devuelve un doble aleatorio entre 0 y 1, y si lo multiplicamos por uno más la diferencia entre topy bottom, obtendremos un doble en algún lugar entre 0y 1+b-a.

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

Math.floorredondea el número al entero más cercano. Entonces ahora tenemos todos los enteros entre 0y top-bottom. El 1 parece confuso, pero debe estar allí porque siempre estamos redondeando hacia abajo, por lo que el número superior nunca se alcanzará sin él. El decimal aleatorio que generamos debe estar en el rango 0para (1+top-bottom)poder redondear hacia abajo y obtener un int en el rango 0paratop-bottom

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

El código en el ejemplo anterior nos dio un número entero en el rango 0y top-bottom, por lo tanto, todo lo que tenemos que hacer ahora es agregar bottoma ese resultado para obtener un número entero en el rango bottome topinclusive. :RE

NOTA: Si pasa un valor no entero o el número mayor primero, obtendrá un comportamiento indeseable, pero a menos que alguien lo solicite, no voy a profundizar en el código de verificación de argumentos, ya que está bastante lejos de la intención de la pregunta original .

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

Alternativa si está utilizando Underscore.js puede usar

_.random(min, max)

Devuelve un número aleatorio entre 1 y 10:

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

Devuelve un número aleatorio entre 1 y 100:

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

Si necesita una variable entre 0 y max, puede usar:

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

Las otras respuestas no tienen en cuenta los parámetros perfectamente razonables de 0y 1. En su lugar, debe usar el en round lugar de 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

Aquí está la implementación MS DotNet de la clase 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;
}());

Utilizar:

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

Use esta función para obtener números aleatorios entre el rango dado

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

Después de generar un número aleatorio utilizando un programa de computadora, todavía se considera como un número aleatorio si el número seleccionado es parte o el número completo del inicial. Pero si se cambió, entonces los matemáticos no lo aceptan como un número aleatorio y pueden llamarlo un número sesgado. Pero si está desarrollando un programa para una tarea simple, este no será un caso a considerar. Pero si está desarrollando un programa para generar un número aleatorio para un material valioso como un programa de lotería o un juego de azar, la administración rechazará su programa si no tiene en cuenta el caso anterior.

Entonces, para ese tipo de personas, aquí está mi sugerencia:

Genere un número aleatorio usando Math.random(). (Diga esto 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 sabe cómo leer la tabla de números aleatorios para elegir un número aleatorio, sabe que el proceso anterior (multiplicar por 1, 10, 100, etc.) no viola el que mencioné al principio. (Porque solo cambia el lugar del punto decimal.)

Estudie el siguiente ejemplo y desarrolle según sus necesidades.

Si necesita una muestra [0,9], entonces el piso de n * 10 es su respuesta y si necesita [0,99] entonces el piso de n * 100 es su respuesta y así sucesivamente.

Ahora deja entrar en tu rol:

Has pedido números entre un rango específico. (En este caso, estás sesgado dentro de ese rango. - Al tomar un número de [1,6] tirando un dado, entonces estás sesgado en [1,6] pero aún así es aleatorio si y solo si el dado es imparcial .)

Así que considere su rango ==> [78, 247] número de elementos del rango = 247 - 78 + 1 = 170; (ya que ambos límites son inclusivos.

/*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: En el método uno, primero creé una matriz que contiene números que necesita y luego los puse al azar en otra matriz. En el método dos, genere números al azar y verifique que estén en el rango que necesita. Luego póngalo en una matriz. Aquí generé dos números aleatorios y usé el total de ellos para maximizar la velocidad del programa minimizando la tasa de falla que obtenía un número útil. Sin embargo, agregar números generados también dará cierta parcialidad. Por lo tanto, recomendaría mi primer método para generar números aleatorios dentro de un rango específico.

En ambos métodos, su consola mostrará el resultado. (Presione f12 en Chrome para abrir la consola)

Para un entero aleatorio con un rango, intente:

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

Para probar esta función y las variaciones de esta función, guarde el siguiente HTML / JavaScript en un archivo y ábralo con un navegador. El código producirá un gráfico que muestra la distribución de un millón de llamadas a funciones. El código también registrará los casos límite, por lo que si la función produce un valor mayor que el máximo, o menor que el mínimo, usted.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>

Para obtener un número aleatorio que diga entre 1 y 6, primero haga:

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

Esto multiplica un número aleatorio por 6 y luego le agrega 0.5. Luego redondea el número a un entero positivo haciendo:

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

Esto redondea el número al número entero más cercano.

O para hacerlo más comprensible, haga esto:

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

En general, el código para hacer esto usando variables es:

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

La razón para quitar 0.5 del valor mínimo es porque usar solo el valor mínimo le permitiría obtener un número entero que fuera uno más que su valor máximo. Al quitar 0.5 del valor mínimo, esencialmente evita que el valor máximo se redondee hacia arriba.

Espero que ayude.

Usando el siguiente código puede generar una matriz de números aleatorios, sin repetir, en un rango dado.

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

Sé que esta pregunta ya está respondida, pero mi respuesta podría ayudar a alguien.

Encontré este método simple en W3Schools:

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

Espero que esto ayude a alguien.

Número entero aleatorio entre el más bajo y el más alto:

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

No es la solución más elegante ... pero algo rápido.

Esto es lo que uso para generar números aleatorios.

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

Realizamos la ejecución high++porque Math.random()genera un número aleatorio entre 0, (inclusive) y 1 (exclusivo). El excluido significa que debemos aumentar el valor alto en uno antes de ejecutar cualquier cálculo matemático. Luego restamos bajo de alto, dándonos el número más alto para generar: bajo, luego + bajo, devolviendo el alto a la normalidad, y haciendo que el número más bajo al menos sea bajo. luego devolvemos el número resultante

random(7,3) podría volver 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 una matriz llena de un número de hasta 3 dígitos que sería un máximo de 999. Este código es muy corto.

Aquí hay un ejemplo de una función de JavaScript que puede generar un número aleatorio de cualquier longitud especificada sin usar 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;
    }

Esta es mi opinión sobre un número aleatorio en un rango, ya que quería obtener un número aleatorio dentro de un rango de base a exponente. Por ejemplo, base = 10, exponente = 2, da un número aleatorio de 0 a 100, idealmente, y así sucesivamente.

si ayuda a usarlo, aquí está:

// 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() es rápido y adecuado para muchos propósitos, pero no es apropiado si necesita valores criptográficamente seguros (no es seguro) o si necesita números enteros de una distribución imparcial completamente uniforme (el enfoque de multiplicación utilizado en otras respuestas produce ciertos valores un poco más a menudo que otros).

En tales casos, podemos usar crypto.getRandomValues()para generar enteros seguros y rechazar cualquier valor generado que no podamos asignar de manera uniforme en el rango objetivo. Esto será más lento, pero no debería ser significativo a menos que esté generando cantidades extremadamente grandes de valores.

Para aclarar el problema de la distribución sesgada, considere el caso en el que queremos generar un valor entre 1 y 5, pero tenemos un generador de números aleatorios que produce valores entre 1 y 16 (un valor de 4 bits). Queremos tener el mismo número de valores generados que se asignen a cada valor de salida, pero 16 no se divide equitativamente por 5: deja un resto de 1. Por lo tanto, debemos rechazar 1 de los posibles valores generados, y solo continuar cuando obtengamos uno de los 15 valores menores que se pueden mapear uniformemente en nuestro rango objetivo. Nuestro comportamiento podría parecerse a este pseudocódigo:

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.

El siguiente código utiliza una lógica similar, pero en su lugar genera un número entero de 32 bits, porque ese es el tamaño entero común más grande que puede ser representado por el numbertipo estándar de JavaScript . (Esto podría modificarse para usar BigInts si necesita un rango mayor). Independientemente del rango elegido, la fracción de valores generados que se rechazan siempre será menor que 0.5, por lo que el número esperado de rechazos siempre será menor que 1.0 y usualmente cerca de 0.0; no necesita preocuparse por que se repita para siempre.

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

Para obtener un número entero aleatorio cripto-fuerte en ragne [x, y] intente

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

console.log(cs(4,8))

Puedes este fragmento de código,

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 escribió una gran respuesta, pero fue un poco demasiado complejo para mí. Entonces, encontré una explicación aún más simple de los mismos conceptos en https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation por Jason Anello.

NOTA: Lo único importante que debe saber antes de leer la explicación de Jason es una definición de "truncar". Él usa ese término cuando describe Math.floor(). El diccionario de Oxford define "truncar" como:

Acorte (algo) cortando la parte superior o el extremo.

Esto puede manejar la generación de números aleatorios ÚNICOS de hasta 20 dígitos

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

/ * ¿Escribir una función llamada randUpToque acepta un número y devuelve un número entero aleatorio entre 0 y ese número? * /

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

/ * Escriba una función llamada randBetweenque acepte dos números que representen un rango y devuelva un número entero aleatorio entre esos dos números. * /

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

/ * Escriba una función llamada randFromTillque acepte dos números que representen un rango y devuelva un número aleatorio entre min (inclusive) y max (exclusivo). * /

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

/ * Escribe una función llamada randFromToque acepta dos números que representan un rango y devuelve un entero aleatorio entre min (inclusive) y max (inclusive) * /

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

Hice esta función que tiene en cuenta opciones como min, max, exclude (una lista de entradas para excluir) y seed (en caso de que desee un generador aleatorio sembrado).

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
}

Se puede usar como:

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

O más simplemente:

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

Entonces puedes hacer:

let item = some_list[n]

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

• random (min, max) genera un número aleatorio entre min (inclusive) y max (exclusivo)

• Math.floor redondea un número hacia abajo al entero más cercano

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

Entonces, para generar un entero aleatorio entre 4 y 8 inclusive, llame a la función anterior con los siguientes argumentos:

generateRandomInteger (4,9)

Mi método para generar un número aleatorio entre 0 yn, donde n <= 10 (n excluido):

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