Generar un número aleatorio entre dos números en JavaScript
¿Hay alguna manera de generar un número aleatorio en un rango especificado con JavaScript?
Por ejemplo: un rango especificado de 1 a 6 donde el número aleatorio podría ser 1, 2, 3, 4, 5 o 6.
Respuesta #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 empiezan en 1. Así que puedes obtener un número aleatorio de 10 a 15, por ejemplo. Flexibilidad.
Respuesta #2
Importante
Si quisieras 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))
Respuesta #3
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;
}
Devuelve 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
const rand1 = Math.floor(Math.random() * 11);
// 1 -> 10
const rand2 = Math.floor(Math.random() * 10) + 1;
// 5 -> 20
const rand3 = Math.floor(Math.random() * 16) + 5;
// -10 -> (-2)
const rand4 = Math.floor(Math.random() * 9) - 10;
console.log(rand1);
console.log(rand2);
console.log(rand3);
console.log(rand4);** Y siempre es agradable que te lo recuerden (Mozilla):
Math.random() no proporciona números aleatorios seguros criptográficamente. No los use para nada relacionado con la seguridad. Use la API Web Crypto en su lugar, y más precisamente, el método window.crypto.getRandomValues().
Respuesta #4
Resumen
function generateRandomInteger(min, max) {
return Math.floor(min + Math.random()*(max - min + 1))
}
Para obtener el número aleatorio generateRandomInteger(-20, 20);
EXPLICACIÓN ABAJO
integer - A number which is not a fraction; a whole numberNecesitamos obtener un número aleatorio, digamos X entre mínimo y máximo. X, mínimo y máximo son todos enteros
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 que es
0 <= (X - min) * r <= (max - min) * r
Ahora, vamos a añadir de nuevo min a la ecuación
mín <= mín + (X - mín) * r <= mín + (máx - mín) * r
Para cualquier X dado, la ecuación anterior se cumple solo cuando r tiene un rango de [0,1]. Para cualquier otro valor de r, la ecuación anterior no se cumple.
Aprende más sobre los rangos [x,y] o (x,y) aquí
Nuestro siguiente paso es encontrar una función que siempre produzca un valor que tenga un rango de [0,1]
Ahora, el rango de r, es decir, [0,1], es muy similar a la función Math.random() en Javascript. ¿No es así?
La función Math.random() devuelve un número de punto flotante pseudoaleatorio en el rango [0, 1); es decir, desde 0 (inclusive) hasta pero sin incluir 1 (exclusivo)
Función aleatoria usando Math.random() 0 <= r < 1
Observe que en Math.random() el límite izquierdo es inclusivo y el límite derecho es exclusivo. Esto significa que min + (max - min) * r se evaluará teniendo un rango de [min, max)
Para incluir nuestro límite derecho, es decir, [min,max], aumentamos el límite derecho en 1 y redondeamos el resultado hacia abajo.
function generateRandomInteger(min, max) {
return Math.floor(min + Math.random()*(max - min + 1))
}
Para obtener el número aleatorio
generarEnteroAleatorio(-20, 20);
Respuesta #5
Otras soluciones:
(Math.random() * 6 | 0) + 1~~(Math.random() * 6) + 1
Probar en línea
Respuesta #6
O, en Guion Bajo
_.random(min, max)
Respuesta #7
var x = 6; // can be any number
var rand = Math.floor(Math.random()*x) + 1;
Respuesta #8
jsfiddle: https://jsfiddle.net/cyGwf/477/
Entero Aleatorio: para obtener un entero aleatorio entre min y max, utiliza 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 Aleatorio de Punto Flotante: para obtener un número aleatorio de punto flotante entre min y max, utiliza 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
Respuesta #9
Obtener un número entero aleatorio entre 0 y 400
let rand = Math.round(Math.random() * 400)
document.write(rand)Obtén un número entero aleatorio entre 200 y 1500
let range = {min: 200, max: 1500}
let delta = range.max - range.min
const rand = Math.round(range.min + Math.random() * delta)
document.write(rand)Usando funciones
function randBetween(min, max){
let delta = max - min
return Math.round(min + Math.random() * delta)
}
document.write(randBetween(10, 15));// JavaScript ES6 arrow function
const randBetween = (min, max) => {
let delta = max - min
return Math.round(min + Math.random() * delta)
}
document.write(randBetween(10, 20))Respuesta #10
Las matemáticas no son mi punto fuerte, pero he estado trabajando en un proyecto donde necesitaba generar muchos números aleatorios tanto positivos como negativos.
function randomBetween(min, max) {
if (min < 0) {
return min + Math.random() * (Math.abs(min)+max);
}else {
return min + Math.random() * max;
}
}
Por ejemplo
randomBetween(-10,15)//or..
randomBetween(10,20)//or...
randomBetween(-200,-100)
Por supuesto, también puedes agregar cierta validación para asegurarte de no hacer esto con nada que no sean números. Además, asegúrate de que min siempre sea menor o igual que max.
Respuesta #11
ES6/Versión de funciones flecha basada en el código de Francis (es decir, la respuesta principal):
const randomIntFromInterval = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);
Respuesta #12
Escribí una función más flexible que puede darte un número aleatorio, pero no solo 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 corregida.
Respuesta #13
Math.random() es rápido y adecuado para muchos propósitos, pero no es apropiado si necesitas valores seguros criptográficamente (no es seguro), o si necesitas enteros de una distribución completamente uniforme e imparcial (el enfoque de multiplicación utilizado en otras respuestas produce ciertos valores ligeramente 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 uniformemente al rango objetivo. Esto será más lento, pero no debería ser significativo a menos que estés generando una cantidad extremadamente grande de valores.
Para aclarar la preocupación sobre 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 que el mismo número de valores generados se asignen a cada valor de salida, pero 16 no se divide uniformemente entre 5: deja un resto de 1. Por lo tanto, necesitamos rechazar 1 de los posibles valores generados, y solo continuar cuando obtengamos uno de los 15 valores menores que se pueden mapear de manera uniforme en nuestro rango objetivo. Nuestro comportamiento podría verse así en 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 genera un entero de 32 bits en su lugar, porque ese es el tamaño de entero común más grande que puede representarse con el tipo number 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 a 0.5, por lo que el número esperado de rechazos siempre será menor a 1.0 y generalmente cercano a 0.0; no necesita preocuparse de que se ejecute el bucle indefinidamente.
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]Respuesta #14
La solución mejor calificada no es matemáticamente correcta, al igual que 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, así que Math.floor(Math.random() * 6) + 1 devuelve un porcentaje de 6 (máximo: 5, mínimo: 0) y suma 1. El autor tuvo suerte de que el límite inferior fuera 1., porque el piso del porcentaje devolverá "máximamente" 5, lo que es 1 menos que 6, y ese 1 será añadido por el límite inferior 1.
El problema ocurre cuando el límite inferior es mayor que 1. Por ejemplo, Tarea: generar un número aleatorio entre 2 y 6.
(siguiendo la lógica del autor) Math.floor(Math.random() * 6) + 2, se observa claramente que si obtenemos 5 aquí -> Math.random() * 6 y luego le sumamos 2, el resultado será 7, lo cual supera el 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 estamos obteniendo un 0%-99% del número "12", lo cual excederá con creces el límite deseado de 12.
Entonces, la lógica correcta es tomar la diferencia entre el límite inferior y el límite superior, sumar 1, y solo entonces redondear hacia abajo (para restar 1, porque Math.random() devuelve 0 - 0.99, por lo que no hay manera de obtener el límite superior completo, por eso estamos sumando 1 al límite superior para obtener como máximo el 99% de (límite superior + 1) y luego lo redondeamos hacia abajo para deshacernos del exceso). Una vez que tenemos el porcentaje redondeado hacia abajo de (diferencia + 1), podemos agregar el 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.
P.D.: Incluso los comentarios bajo la respuesta mejor calificada estaban incorrectos, ya que la gente olvidó agregar 1 a la diferencia, lo que significa que nunca obtendrán el límite superior (sí, podría ser el caso si no quieren obtenerlo en absoluto, pero el requisito era incluir el límite superior).
Respuesta #15
Ejemplo
Devuelve un número aleatorio entre 1 y 10:
Math.floor((Math.random() * 10) + 1);
El resultado podría ser: 3
Pruébalo tú mismo: aquí
--
o usando lodash/underscore:
_.random(min, max)Docs: - lodash - undescore