Genere un número aleatorio entre dos números en JavaScript

2121

¿Hay alguna forma de generar un número aleatorio en un rango específico (por ejemplo, de 1 a 6: 1, 2, 3, 4, 5 o 6) en JavaScript?

dieciséis
2701

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.

20
  • 5
    esto también es genial porque si alguien no incluye el toargumento, el fromargumento se duplica como el máximo
    Jason
    6 de febrero de 2013 a las 1:53
  • 18
    Hola. Esto es de MDN: Returns a floating-point, pseudo-random number in the range [0, 1) that is, from 0 (inclusive) up to but not including 1 (exclusive), which you can then scale to your desired range.( developer.mozilla.org/en-US/docs/JavaScript/Reference/… ) 9/04/2013 a las 20:12
  • 6
    Lea el comentario anterior. Random está dentro de [0,1), no [0,1]. 21/06/2013 a las 13:41
  • 4
    Funciona muy bien si el número más bajo es 0. 27/10/2013 a las 20:47
  • 3
    Tenga en cuenta que esta solución es correcta solo si min y max son números enteros; de lo contrario, puede obtener un resultado en el intervalo [min, ceil (max)]. Es decir, puede obtener un resultado que está fuera de rango porque es superior al máximo. 7 de julio de 2014 a las 9:40
2386

Importante

El siguiente código solo funciona si el valor mínimo es "1". No funciona para valores mínimos distintos de "1".

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

    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) - final (1) )
27
  • 51
    Si bien esto funcionaría, @Mike, sería mejor señalar la versión más genérica, ya que Francisc la tiene a continuación :-). 5 de agosto de 2013 a las 14:38
  • 69
    -1. Después de buscar en Google encontré esta pregunta, el título es "" Generar valor aleatorio entre dos números en Javascript "." No funcionará si el valor mínimo es 0
    Ydhem
    8/10/2013 a las 1:44
  • 20
    No funciona si desea un número entre dos números más grandes, por ejemplo. Math.floor (Math.random () * 900) + 700
    Rob
    25/11/2013 a las 16:12
  • 21
    Eso solo funciona si el mínimo es 1. Si el mínimo es 2 y todavía usamos Math.floor(Math.random() * 6) + 2significa que si los Math.random()resultados son 0.99, nuestro valor aleatorio sería7 12 de diciembre de 2013 a las 16:15
  • 31
    Este código no es bueno porque no funciona con ningún número. El código de @Francisc es el correcto. 22 dic '13 a las 14:39
411

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

Math.random() does not provide cryptographically secure random numbers. Do not use them for anything related to security. Use the Web Crypto API instead, and more precisely the window.crypto.getRandomValues() method.

5
  • Algo que me confundió ... Math.floor (..) asegura que el número es un entero donde Math.round (..) daría una distribución desigual. Ref: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
    alikuli
    3 de agosto de 2016 a las 10:45
  • 1
    Confío en esta respuesta. ¿Alguien puede dar un enlace o una explicación clara de por qué funciona esto? Quizás un ejemplo de cómo Math.round daría un sesgo, y ¿por qué eso significa que tenemos que usar esta fórmula de apariencia bastante compleja? 11/10/2016 a las 9:05
  • 8
    @alikuli Para una gama de [1,2], hay 25% de posibilidades Math.random()que le dará un número de uno de éstos [0,0.49], [0.5,0.99], [1,1.49], [1.5,1.99]. Redondear esos intervalos daría como resultado 0, 1, 1, 2 que no es una distribución uniforme. Pisarlos da como resultado 0, 0, 1, 1. 30/0317 a las 22:24
  • 1
    @shuji Esta es , entre otras, la respuesta correcta. Solo quería aclarar por qué el uso de Math.roundover Math.floordaría resultados diferentes. 20/11/2017 a las 13:23
  • La solución más precisa que he encontrado: function getRandomInt(min, max) { return Math.round((min - 0.5) + Math.random() * (max - min + 1)); }
    Sadik
    23 de mayo de 2020 a las 14:34
97

Otras soluciones:

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

Prueba en línea

8
  • 8
    ¿Le importaría explicar (o dar referencias a) la ~~ sintaxis? ¡No lo había visto antes! Solución elegante pero difícil de entender.
    DiegoDD
    31 de mayo de 2013 a las 22:49
  • 34
    Double Tilde ~~a y Bitwise OR (a | 0) son formas más rápidas de escribir Math.floor (a)
    edi9999
    18/07/2013 a las 15:39
  • 8
    a | 0también es la forma más rápida y optimizada de convertir una cadena en un número entero. Solo funciona con cadenas que contienen números enteros ( "444"y "-444"), es decir, sin flotantes / fracciones. Da un 0por todo lo que falla. Es una de las principales optimizaciones detrás de asm.js.
    pilau
    21/11/2014 a las 7:35
  • 1
    @ edi9999 ¿más rápido de escribir, pero también más rápido de ejecutar?
    kbtz
    26 de septiembre de 2015 a las 18:49
  • 4
    Nota: si está trabajando con números realmente grandes, la tilde doble no funcionará. Prueba ~~(Math.random() * (50000000000000 - 0 + 1)) + 0yMath.floor(Math.random() * (50000000000000 - 0 + 1)) + 0
    BrunoLM
    25 de mayo de 2016 a las 23:50
sesenta y cinco

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 mínimo y máximo.

¿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 que 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, escojamos una función que resulte en r tal que satisfaga nuestro rango de ecuaciones como [min, max]. Esto solo es posible si 0 <= r <= 1

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

The Math.random() function returns a floating-point, pseudo-random number in the range [0, 1); that is, from 0 (inclusive) up to but not including 1 (exclusive)

Por ejemplo,

Caso r = 0

min+ 0 * ( max- min) = min

Caso r = 1

min+ 1 * ( max- min) = máx.

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

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

El resultado anterior X es un número 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);

0
30

O, en subrayado

_.random(min, max)
0
28
var x = 6; // can be any number
var rand = Math.floor(Math.random()*x) + 1;
0
25

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

Entero aleatorio : para obtener un entero aleatorio entre miny max, use 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 punto flotante aleatorio entre miny max, use 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

17

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.

1
  • 5
    Esto es simplemente incorrecto. min + Math.random() * maxle dará números entre min y min + max, que no es lo que desea. La primera rama de la ifes correcta, pero podría simplificarse para decir return min + Math.random() * (max - min), cuál es la solución correcta independientemente de si min es positivo o negativo (vea las otras respuestas). Además, tenga en cuenta que aún debe nivelar el resultado si no desea fracciones.
    Avish
    23 de mayo de 2013 a las 16:09
13

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);
1
  • 1
    ¡Bonito! Es muy útil proporcionar los valores miny max. Estaba buscando esta respuesta.
    Victor
    17 de mayo a las 18:19
11

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.

4
  • Esta no es una buena solución ya que no funcionará con cero como valor mínimo. Vea la respuesta de @Lior. 11/09/15 a las 9:45
  • 1
    Por supuesto, funciona con cero como valor mínimo. ¿Has probado? No hay ninguna razón por la que no funcione. No funcionará con 0 como intervalo, lo cual no es extraño (¿intervalo = 0? ...). 14/09/15 a las 10:01
  • Ejecuté varias veces esta función con cero como valor mínimo y nunca obtuve cero en la salida. O no tengo la suerte ... 14 de septiembre de 2015 a las 10:11
  • Tienes razón. "+ intervalo" estaba en el lugar incorrecto. Pruébelo ahora por favor. Lo extraño que a veces console.log me da 0.300000004 en lugar de 0.3 como 3 * 0.1 no sería exactamente 0.3. 14 de septiembre de 2015 a las 10:40
11

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 - sin puntuación

1
  • 1
    entonces necesitas 9 o 10, ¿verdad? En caso afirmativo: const randomNumber = Math.floor ((Math.random () * 10) + 1) const nineOrTen = randomNumber% 2 === 0? 9:10 2/08/18 a las 14:20
9

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

Esto admite números enteros negativos:

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

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

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 asignar de manera uniforme al 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 de manera uniforme 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 numbertipo estándar de JavaScript . (Esto podría modificarse para usar BigInts si necesita un rango más grande). 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 generalmente cerca de 0.0; no necesita 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]
2
  • 2
    @ 2xSamurai Allí, actualicé la respuesta para explicar por qué podrías necesitar esto y cómo funciona. ¿Eso está mejor? :PAG
    Jeremy
    5 abr 19 a las 19:38
  • 1
    No es una exageración si desea números aleatorios criptográficamente seguros y distribuidos uniformemente. Generar números aleatorios que cumplan con esos requisitos es difícil. Gran respuesta, @JeremyBanks. 25 dic 2019 a las 10:25
7

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 porcentaje, por lo que Math.floor(Math.random() * 6) + 1devuelve un porcentaje de 6 (máx .: 5, mín .: 0) y agrega 1 . El autor tuvo suerte de que el límite inferior fuera 1. , porque el porcentaje de piso 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() * 6y luego agregamos 2, el resultado será 7 que va más allá del límite deseado de 6.

Otro ejemplo, Tarea: generar aleatoriamente 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 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 el límite inferior y el límite superior sumar 1 , y solo luego 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 a límite superior para obtener un máximo del 99% de (límite superior + 1) y luego lo nivelamos 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 que 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 olvidaron agregar 1 a la diferencia , lo que significa que nunca obtendrá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) .

1
  • Math.floor (Math.random () * ((up_boundary - low_boundary) + 1)) + low_boundary
    M22
    17 de feb a las 17:37
6

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

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

Agregando floatcon una versión de precisión fija basada en la intversió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
}

asi que:

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

y para int respuesta

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

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
8
  • esto nunca sacará 6 si max = 6 y min = 0 16 de septiembre de 2020 a las 6:29
  • @mesqueeb Edité mi respuesta, como Math.random()nunca será 1. 17/09/20 a las 19:01
  • 1
    Creo que su respuesta es buena en "teoría", pero sería mucho mejor si pudiera indicar claramente en su respuesta si max = 6 "incluiría" la posibilidad de 6 o no, y si min = 1 "incluiría" la posibilidad de 1? Esto se puede leer de manera muy ambigua y puede confundir a la gente. ¿Es "máximo 6 - incluyendo 6" o "máximo 6 - sin incluir 6" ... Lo mismo para "mínimo". 18 de septiembre de 2020 a las 4:53
  • Actualicé mi respuesta para eliminar la ambigüedad y agregar la posibilidad de números negativos. 18 de septiembre de 2020 a las 15:04
  • temp no se utiliza. 9/10/20 a las 9:32
4

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

Esto debería funcionar:

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

Número entero aleatorio cripto-fuerte en el rango [a, b] (suposición: a <b)

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

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

Un trazador de líneas simple:

Math.floor( Math.random() * MAX_NUMBER ) + MIN_NUMBER

P.ej:

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

Esto tiene un retraso de aproximadamente nueve años, pero randojs.com hace que esto sea una simple frase :

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

Intente usar:

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

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.

1

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í está:

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

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


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

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

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