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

Importante

O código a seguir funciona apenas se o valor mínimo é 1. Não funciona para valores mínimos diferentes de 1.

Se você deseja obter um número inteiro aleatório entre 1 ( e apenas 1 ) e 6, calcula:

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

Onde:

• 1 é o número inicial
• 6 é o número de resultados possíveis (1 + início (6) - final (1) )

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

O que ele faz "extra" é que permite intervalos aleatórios que não começam com 1. Portanto, você pode obter um número aleatório de 10 a 15, por exemplo. Flexibilidade.

Math.random ()

Retorna um número aleatório inteiro entre min ( incluído ) e max ( incluído ):

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

Ou qualquer número aleatório entre min ( incluído ) e máximo ( não incluído ):

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

Exemplos úteis (números inteiros):

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

** E sempre bom ser lembrado (Mozilla):

Math.random () não fornece números aleatórios criptograficamente seguros. Não os use para qualquer coisa relacionada à segurança. Use a API Web Crypto e, mais precisamente, o método window.crypto.getRandomValues ​​().

Outras soluções:

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

Experimente on-line

TL; DR

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

Para obter o número aleatório generateRandomInteger(-20, 20);

EXPLICAÇÃO ABAIXO

Precisamos obter um número inteiro aleatório, digamos X entre min e max.

Direita?

ie min <= X <= max

Se subtrairmos min da equação, isso é equivalente a

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

Agora, vamos multiplicar isso com um número aleatório r que é

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

Agora, vamos adicionar de volta min à equação

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

Agora, vamos escolher uma função que resulte em r tal que satisfaça nosso intervalo de equações como [min, max]. Isso só é possível se 0 <= r <= 1

ESTÁ BEM. Agora, o intervalo de r, ou seja, [0,1] é muito semelhante ao resultado da função Math.random (). Não é?

A função Math.random () retorna um número pseudo-aleatório de ponto flutuante no intervalo [0, 1); ou seja, de 0 (inclusive) até mas não incluindo 1 (exclusivo)

Por exemplo,

Caso r = 0

min+ 0 * ( max- min) = min

Caso r = 1

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

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

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

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

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

Para obter o número aleatório

generateRandomInteger(-20, 20);

Ou, em sublinhado

_.random(min, max)

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

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

Número inteiro aleatório : para obter um número inteiro aleatório entre mine 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 aleatório entre mine max, use o seguinte código

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

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

A matemática não é o meu ponto forte, mas tenho trabalhado em um projeto em que precisava gerar muitos números aleatórios 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)

Obviamente, você também pode adicionar alguma validação para garantir que não faça isso com nada além de números. Verifique também se min é sempre menor ou igual ao máximo.

Eu escrevi uma função mais flexível, que pode fornecer um número aleatório, 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

Retorne um número aleatório entre 1 e 10:

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

O resultado pode ser: 3

Experimente você mesmo: aqui

-

ou usando lodash / undescore:

_.random(min, max)

Documentos: - lodash - undescore

Apesar de muitas respostas e quase o mesmo resultado. Gostaria de adicionar 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 aleatórios não passa 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));
}

Eu estava pesquisando um gerador de números aleatórios escrito em TypeScript e escrevi isso depois de ler todas as respostas, espero que funcione para codificadores TypeScript.

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

Math.random() é rápido e adequado para muitos propósitos, mas não é apropriado se você precisar de valores criptograficamente seguros (não é seguro) ou se precisar de números inteiros de uma distribuição imparcial completamente uniforme (a abordagem de multiplicação usada em outras respostas produz determinados valores com uma frequência um pouco mais frequente do que outros).

Nesses casos, podemos usar crypto.getRandomValues()para gerar números inteiros seguros e rejeitar quaisquer valores gerados que não possamos mapear uniformemente no intervalo de destino. Isso será mais lento, mas não deve ser significativo, a menos que você esteja gerando um número extremamente grande de valores.

Para esclarecer a questão da distribuição tendenciosa, considere o caso em que queremos gerar um valor entre 1 e 5, mas temos um gerador de números aleatórios que produz valores entre 1 e 16 (um valor de 4 bits). Queremos ter o mesmo número de valores gerados mapeados para cada valor de saída, mas 16 não se divide uniformemente por 5: deixa um restante de 1. Portanto, precisamos rejeitar 1 dos possíveis valores gerados e continuar apenas quando obtivermos um dos 15 valores menores que podem ser mapeados uniformemente em nosso intervalo de segmentação. Nosso comportamento pode se parecer com 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.

O código a seguir usa lógica semelhante, mas gera um número inteiro de 32 bits, porque esse é o maior tamanho inteiro comum que pode ser representado pelo numbertipo padrão do JavaScript . (Isso pode ser modificado para usar BigInts, se você precisar de um intervalo maior.) Independentemente do intervalo escolhido, a fração dos valores gerados que são rejeitados sempre será menor que 0,5, portanto, o número esperado de rejeições sempre será menor que 1,0 e geralmente perto de 0,0; você não precisa se preocupar com isso para sempre.

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]

Adicionando floatcom versão de precisão fixa com base na intversão na resposta do @ Francisc:

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

tão:

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

e para resposta int

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

Número inteiro aleatório cripto-forte no intervalo [a, b] (suposição: a <b)

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

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

Isso deve funcionar:

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

Eu descobri uma ótima maneira nova de fazer isso usando os parâmetros padrão do ES6. É muito bacana, pois permite um ou dois argumentos. Aqui está:

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

Isso está com cerca de nove anos de atraso, mas o randojs.com torna isso uma linha simples:

rando(1, 6)

Você só precisa adicionar isso ao cabeçalho do seu documento html e pode fazer o que quiser com aleatoriedade facilmente. Valores aleatórios de matrizes, elementos jquery aleatórios, propriedades aleatórias de objetos e até mesmo impedir repetições, se necessário.

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

Isso funciona para mim e produz valores como a função de biblioteca padrão random.randint do Python :

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

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

Tente usar:

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

retornar 1-6 como um dado basicamente,

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