Gere um número random entre dois números em JavaScript

Existe uma maneira de gerar um número random em um intervalo especificado (por exemplo, de 1 a 6: 1, 2, 3, 4, 5 ou 6) em JavaScript?

Se você quisesse ficar entre 1 e 6, calcularia:

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

Onde:

  • 1 é o número inicial
  • 6 é o número de resultados possíveis (1 + início (6) – fim (1) )
 function randomIntFromInterval(min,max) { return Math.floor(Math.random()*(max-min+1)+min); } 

O que ele faz “extra” é que ele permite intervalos randoms que não começam com 1. Assim, você pode obter um número random de 10 a 15, por exemplo. Flexibilidade.

Math.random ()

Da documentação da Mozilla Developer Network:

 // Returns a random integer between min (include) and max (include) Math.floor(Math.random() * (max - min + 1)) + min; 

Exemplos úteis:

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

Outras soluções:

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

A function Math.random () retorna um número pseudo-random de ponto flutuante no intervalo [0, 1); isto é, de 0 (inclusive) até, mas não incluindo 1 (exclusivo)

Vamos add o min randomly de 0 a max-min

Caso 0

min + 0 * ( maxmin ) = min

Caso 1

min + 1 * ( maxmin ) = max

Caso Aleatório usando Math.random 0 < = r <1

min + r * ( maxmin ) = X , em que X tem intervalo de min < = X < max

O resultado acima X é um numérico random. No entanto, devido a Math.random () nosso limite esquerdo é inclusivo, e o limite direito é exclusivo. Para include nosso limite direito, aumentamos o limite direito em 1 e aumentamos o resultado.

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

Para obter o número random

generateRandomInteger(-20, 20) ;

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

Ou, no sublinhado

 _.random(min, max) 

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

Random Integer : para obter um número inteiro random entre min e max , use o seguinte 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 Ponto Flutuante Aleatório : para obter um número de ponto flutuante random entre min e max , use o seguinte código

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

Referência: https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/random

A matemática não é o meu ponto forte, mas tenho trabalhado em um projeto onde precisei gerar muitos números randoms entre positivos e negativos.

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

Por exemplo

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

Naturalmente, você também pode adicionar alguma validação para garantir que não faça isso com nada além de números. Também certifique-se de que min é sempre menor ou igual a max.

Eu escrevi uma function mais flexível, que pode lhe dar um número random, mas não apenas um número inteiro.

 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 

Versão fixa.

Exemplo

Retornar um número random entre 1 e 10:

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

O resultado poderia ser: 3

Tente você mesmo: aqui

ou usando lodash / undescore:

_.random(min, max)

Documentos: – lodash – undescore

Eu estava pesquisando gerador de números randoms escrito em TypeScript e eu escrevi isso depois de ler todas as respostas, espero que funcionaria para codificadores de TypeScript.

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

Apesar de muitas respostas e quase o mesmo resultado. Eu gostaria de acrescentar minha resposta e explicar seu funcionamento. Porque é importante entender o seu funcionamento em vez de copiar e colar um código de linha. Gerar números randoms não é nada além de matemática simples.

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

Sentir que você precisa adicionar 1 ao número máximo e, em seguida, subtrair o número mínimo para que nada disso funcione, e eu preciso fazer um monte de números inteiros randoms, esta function funciona.

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

Isso funciona com números negativos e positivos, e estou trabalhando em decimais para uma biblioteca.

Em vez de Math.random() , você pode usar crypto.getRandomValues() para gerar números randoms criptograficamente seguros distribuídos uniformemente. Aqui está um exemplo:

 function randInt(min, max) { var MAX_UINT32 = 0xFFFFFFFF; var range = max - min; if (!(range < = MAX_UINT32)) { throw new Error( "Range of " + range + " covering " + min + " to " + max + " is > " + MAX_UINT32 + "."); } else if (min === max) { return min; } else if (!(max > min)) { throw new Error("max (" + max + ") must be >= min (" + min + ")."); } // We need to cut off values greater than this to avoid bias in distribution // over the range. var maxUnbiased = MAX_UINT32 - ((MAX_UINT32 + 1) % (range + 1)); var rand; do { rand = crypto.getRandomValues(new Uint32Array(1))[0]; } while (rand > maxUnbiased); var offset = rand % (range + 1); return min + offset; } console.log(randInt(-8, 8)); // -2 console.log(randInt(0, 0)); // 0 console.log(randInt(0, 0xFFFFFFFF)); // 944450079 console.log(randInt(-1, 0xFFFFFFFF)); // Uncaught Error: Range of 4294967296 covering -1 to 4294967295 is > 4294967295. console.log(new Array(24).fill().map(n => randInt(8, 12))); // [11, 8, 8, 11, 10, 8, 8, 12, 12, 12, 9, 9, // 11, 8, 11, 8, 8, 8, 11, 9, 10, 12, 9, 11] console.log(randInt(10, 8)); // Uncaught Error: max (8) must be >= min (10). 
 function random(min, max){ return Math.floor(Math.random() * (max - min + 1)) + min; } 

Eu encontrei a solução de Francisc acima não incluiu o número mínimo ou máximo nos resultados, então eu alterei assim:

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