Importante:

Si quisiera obtener un número entero aleatorio entre 1 (y solo 1) y 6, calcularías:

    const rndInt = Math.floor(Math.random() * 6) + 1
    console.log(rndInt)

Dónde:

• 1 es el número de inicio
• 6 es el número de resultados posibles (1 + inicio (6) - fin (1))

function randomIntFromInterval(min, max) { // min and max included 
  return Math.floor(Math.random() * (max - min + 1) + min)
}

const rndInt = randomIntFromInterval(1, 6)
console.log(rndInt)

Lo que hace "extra" es que permite intervalos aleatorios que no comienzan con 1. Por lo tanto, puede obtener un número aleatorio del 10 al 15, por ejemplo. Flexibilidad.

Math.random ()

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

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

Or 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 que te recuerden (Mozilla):

Math.random () no proporciona números aleatorios criptográficamente seguros. No los utilice para nada relacionado con la seguridad. En su lugar, utilice Web Crypto API y, más precisamente, el método window.crypto.getRandomValues ​​().

Otras soluciones:

• (Math.random() * 6 | 0) + 1
• ~~(Math.random() * 6) + 1

Prueba en línea

TL; DR

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

Para obtener el número aleatorio generateRandomInteger(-20, 20);

EXPLICACIÓN A CONTINUACIÓN

Necesitamos obtener un número entero aleatorio, digamos X entre min y max.

¿Derecha?

es decir, min <= X <= max

Si restamos min de la ecuación, esto es equivalente a

0 <= (X - min) <= (max - min)

Ahora, multipliquemos esto con un número aleatorio. r cual es

0 <= (X - min) * r <= (max - min) * r

Ahora, agreguemos min a la ecuación

min <= min + (X - min) * r <= min + (max - min) * r

Ahora, elija una función que resulte en r de modo que satisfaga nuestro rango de ecuaciones como [min, max]. Esto solo es posible si 0 <= r <= 1

está bien. Ahora, el rango de r es decir, [0,1] es muy similar al resultado de la función Math.random (). ¿No es así?

La función Math.random () devuelve un número pseudoaleatorio de punto flotante en el rango [0, 1); es decir, desde 0 (inclusive) hasta pero sin incluir 1 (exclusivo)

Por ejemplo,

Caso r = 0

min + 0 * (max-min) = min

Caso r = 1

min + 1 * (max-min) = max

Caso aleatorio usando Math.random 0 <= r <1

min + r * (max-min) = X, Donde X tiene rango de min <= X < max

El resultado anterior X es un numérico aleatorio. Sin embargo, debido a Math.random (), nuestro límite izquierdo es inclusivo y el límite derecho es exclusivo. Para incluir nuestro límite derecho, aumentamos el límite derecho en 1 y piso el resultado.

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

Para obtener el número aleatorio

generateRandomInteger(-20, 20);

O, en Subrayar

_.random(min, max)

var x = 6; // can be any number
var rand = Math.floor(Math.random()*x) + 1;

jsfiddle: https://jsfiddle.net/cyGwf/477/

Entero aleatorio: para obtener un número entero aleatorio entre min y max, usa el siguiente código

function getRandomInteger(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min)) + min;
}

Número de punto flotante aleatorio: para obtener un número de coma flotante aleatorio entre min y max, usa el siguiente código

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

Referencia: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random

Las matemáticas no son mi punto fuerte, pero he estado trabajando en un proyecto en el que necesitaba generar muchos números aleatorios entre positivos y negativos.

function randomBetween(min, max) {
    if (min < 0) {
        return min + Math.random() * (Math.abs(min)+max);
    }else {
        return min + Math.random() * max;
    }
}

P.ej

randomBetween(-10,15)//or..
randomBetween(10,20)//or...
randomBetween(-200,-100)

Por supuesto, también puede agregar algo de validación para asegurarse de no hacer esto con nada más que números. También asegúrese de que el mínimo sea siempre menor o igual que el máximo.

Escribí una función más flexible que puede darte un número aleatorio pero no solo un entero.

function rand(min,max,interval)
{
    if (typeof(interval)==='undefined') interval = 1;
    var r = Math.floor(Math.random()*(max-min+interval)/interval);
    return r*interval+min;
}

var a = rand(0,10); //can be 0, 1, 2 (...) 9, 10
var b = rand(4,6,0.1); //can be 4.0, 4.1, 4.2 (...) 5.9, 6.0

Versión fija.

Ejemplo

Devuelve un número aleatorio entre 1 y 10:

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

El resultado podría ser: 3

Pruébelo usted mismo: aquí

--

o usando lodash / undescore:

_.random(min, max)

Documentos: - lodash - no puntuado

Versión de las funciones ES6 / Arrow basada en el código de Francis (es decir, la respuesta principal):

const randomIntFromInterval = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);

Estaba buscando un generador de números aleatorios escrito en TypeScript y lo escribí después de leer todas las respuestas, espero que funcione para los codificadores de TypeScript.

    Rand(min: number, max: number): number {
        return (Math.random() * (max - min + 1) | 0) + min;
    }   

A pesar de muchas respuestas y casi el mismo resultado. Me gustaría agregar mi respuesta y explicar su funcionamiento. Porque es importante entender su funcionamiento en lugar de copiar y pegar el código de una línea. Generar números aleatorios no es más que simples matemáticas.

CÓDIGO:

function getR(lower, upper) {

  var percent = (Math.random() * 100);
  // this will return number between 0-99 because Math.random returns decimal number from 0-0.9929292 something like that
  //now you have a percentage, use it find out the number between your INTERVAL :upper-lower 
  var num = ((percent * (upper - lower) / 100));
  //num will now have a number that falls in your INTERVAL simple maths
  num += lower;
  //add lower to make it fall in your INTERVAL
  //but num is still in decimal
  //use Math.floor>downward to its nearest integer you won't get upper value ever
  //use Math.ceil>upward to its nearest integer upper value is possible
  //Math.round>to its nearest integer 2.4>2 2.5>3   both lower and upper value possible
  console.log(Math.floor(num), Math.ceil(num), Math.round(num));
}

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 insesgada 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 mapear uniformemente en el rango objetivo. Esto será más lento, pero no debería ser significativo a menos que esté generando una gran cantidad de valores.

Para aclarar la preocupación por 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 la misma cantidad de valores generados mapeando a cada valor de salida, pero 16 no se divide uniformemente entre 5: deja un resto de 1. Por lo tanto, debemos rechazar 1 de los posibles valores generados y solo continuar cuando obtenemos uno de los 15 valores menores que se pueden mapear uniformemente en nuestro rango objetivo. Nuestro comportamiento podría verse como 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 usa una lógica similar, pero genera un entero de 32 bits en su lugar, porque ese es el tamaño de entero común más grande que se puede representar con el estándar de JavaScript number tipo. (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 cercano a 0.0; no tiene que preocuparse de 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]

para devolver 1-6 como un dado básicamente,

return Math.round(Math.random() * 5 + 1);

La solución mejor calificada no es matemáticamente correcta como los comentarios debajo de ella -> Math.floor(Math.random() * 6) + 1.

Tarea: generar un número aleatorio entre 1 y 6.

Math.random() devuelve un número de punto flotante entre 0 y 1 (como 0.344717274374 o 0.99341293123 por ejemplo), que usaremos como un porcentaje, entonces Math.floor(Math.random() * 6) + 1 devuelve un porcentaje de 6 (max: 5, min: 0) y agrega 1. El autor tuvo suerte de que el límite inferior fuera 1., porque el piso porcentual devolverá "como máximo" 5, que es menos de 6 por 1, y ese 1 se agregará por el límite inferior 1.

El problema ocurre cuando el límite inferior es mayor que 1. Por ejemplo, Tarea: generar aleatorio entre 2 y 6.

(siguiendo la lógica del autor) Math.floor(Math.random() * 6) + 2, obviamente se ve que si obtenemos 5 aquí -> Math.random() * 6 y luego agregue 2, el resultado será 7 que va más allá del límite deseado de 6.

Otro ejemplo, Tarea: generar aleatorio entre 10 y 12.

(siguiendo la lógica del autor) Math.floor(Math.random() * 12) + 10, (perdón por repetir) es obvio que obtenemos 0% -99% por ciento del número "12", que irá mucho más allá del límite deseado de 12.

Entonces, la lógica correcta es tomar la diferencia entre límite inferior y límite superior add 1, y solo entonces el piso (para restar 1, porque Math.random() devuelve 0 - 0.99, por lo que no hay forma de obtener el límite superior completo, por eso agregamos 1 al límite superior para obtener un máximo del 99% de (límite superior + 1) y luego lo reducimos para eliminar el exceso). Una vez que obtenemos el porcentaje de suelo de (diferencia + 1), podemos agregar un límite inferior para obtener el número aleatorio deseado entre 2 números.

La fórmula lógica para eso será: Math.floor(Math.random() * ((up_boundary - low_boundary) + 1)) + 10.

Ps: Incluso los comentarios debajo de la respuesta mejor calificada eran incorrectos, ya que las personas se olvidaron de agregar 1 En el correo electrónico “Su Cuenta de Usuario en su Nuevo Sistema XNUMXCX”. Affordable, lo que significa que nunca alcanzarán el límite superior (sí, podría ser un caso si no quieren obtenerlo en absoluto, pero el requisito era incluir el límite superior).

Adición float con versión de precisión fija basada en el int versión en la respuesta de @ Francisc:

function randomFloatFromInterval (min, max, fractionDigits) {
  const fractionMultiplier = Math.pow(10, fractionDigits)
  return Math.round(
    (Math.random() * (max - min) + min) * fractionMultiplier,
  ) / fractionMultiplier
}

Sun:

randomFloatFromInterval(1,3,4) // => 2.2679, 1.509, 1.8863, 2.9741, ...

y para int respuesta

randomFloatFromInterval(1,3,0) // => 1, 2, 3

Esto debería funcionar:

const getRandomNum = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min

Cripto-fuerte número entero aleatorio en el rango [a, b] (supuesto: a <b)

let rand= (a,b)=> a+(b-a+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0

console.log( rand(1,6) );

Usando una función aleatoria, que se puede reutilizar.

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

Esto admite números enteros negativos:

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

Esto es como nueve años tarde, pero randojs.com hace que esto sea un simple de una sola línea:

rando(1, 6)

Solo necesita agregar esto al encabezado de su documento html, y puede hacer prácticamente lo que quiera con aleatoriedad fácilmente. Valores aleatorios de matrices, elementos jquery aleatorios, propiedades aleatorias de objetos e incluso evitar repeticiones si es necesario.

<script src="https://randojs.com/1.0.0.js"></script>

Intente usar:

function random(min, max) {
   return Math.round((Math.random() *( Math.abs(max - min))) + min);
}
console.log(random(1, 6));

Esta función puede generar un número entero aleatorio entre (e incluyendo) números mínimos y máximos:

function randomNumber(min, max) {
  if (min > max) {
    let temp = max;
    max = min;
    min = temp;
  }

  if (min <= 0) {
    return Math.floor(Math.random() * (max + Math.abs(min) + 1)) + min;
  } else {
    return Math.floor(Math.random() * (max - min + 1)) + min;
  }
}

Ejemplo:

randomNumber(-2, 3); // can be -2, -1, 0, 1, 2 and 3
randomNumber(-5, -2); // can be -5, -4, -3 and -2
randomNumber(0, 4); // can be 0, 1, 2, 3 and 4
randomNumber(4, 0); // can be 0, 1, 2, 3 and 4

Descubrí una nueva forma excelente de hacer esto usando los parámetros predeterminados de ES6. Es muy ingenioso ya que permite un argumento o dos argumentos. Aquí lo tienes:

function random(n, b = 0) {
    return Math.random() * (b-n) + n;
}

Esto funciona para mí y produce valores como el de Python. random.randint función de biblioteca estándar:

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

console.log("Random integer: " + randint(-5, 5));

para un gran número.

var min_num = 900;
var max_num = 1000;
while(true){
    
    let num_random = Math.random()* max_num;
    console.log('input : '+num_random);
    if(num_random >= min_num){
        console.log(Math.floor(num_random));
       break; 
    } else {
        console.log(':::'+Math.floor(num_random));
    }
}

Si el número inicial es 1, como en su ejemplo (1-6), puede usar el método Math.ceil () en lugar de Math.floor ().

Math.ceil(Math.random() * 6)

en lugar de

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

No olvidemos otros métodos matemáticos útiles.