var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;

Math.Aleatório()

A partir doMozilla documentação da rede de desenvolvimento:

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

function getRandomizer(bottom, top) {
    return function() {
        return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
    }
}

Utilização:

var rollDie = getRandomizer( 1, 6 );

var results = ""
for ( var i = 0; i<1000; i++ ) {
    results += rollDie() + " ";    //make a string filled with 1000 random numbers in the range 1-6.
}

Repartição:

Estamos a devolver uma função (tomando emprestado da programação funcional) que, quando chamada, irá devolver um inteiro aleatório entre os valores bottom e top, inclusive. Dizemos "inclusivo" porque queremos incluir tanto de baixo como de cima na gama de números que podem ser devolvidos. Desta forma, getRandomizer( 1, 6 ) vai voltar ou 1, 2, 3, 4, 5, 6.

(o fundo é menor, o topo é maior)

Math.random() * ( 1 + top - bottom )

Math.random() devolve um duplo aleatório entre 0 e 1, e se o multiplicarmos por um mais a diferença entre top e bottom, teremos um duplo algures entre 0 e 1+b-a.

Math.floor( Math.random() * ( 1 + top - bottom ) )

Math.floor reduz o número para o número inteiro mais próximo. Então agora temos todos os inteiros entre 0 e top-bottom. O 1 parece confuso, mas precisa estar lá porque estamos sempre arredondando para baixo, de modo que o número de topo nunca será realmente alcançado sem ele. A casa decimal aleatória que geramos tem de estar em o intervalo 0 para {[17] } para que possamos arredondar e obter um int no intervalo 0 para top-bottom

Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom

O código no exemplo anterior deu-nos um número inteiro no intervalo 0 e top-bottom, então tudo o que precisamos fazer agora é adicionar bottom para que o resultado para obter um número inteiro no intervalo bottom e top inclusiva. : D

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

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

Devolve um número aleatório entre 1 e 100:

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

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

Alternativa se estiver a utilizar sublinhado.js pode utilizar

_.random(min, max)

As outras respostas não têm em conta os parâmetros perfeitamente razoáveis de 0 e 1. Em vez disso, deve usar o round em vez de de ceil ou floor:

function randomNumber(minimum, maximum){
    return Math.round( Math.random() * (maximum - minimum) + minimum);
}

console.log(randomNumber(0,1));  # 0 1 1 0 1 0
console.log(randomNumber(5,6));  # 5 6 6 5 5 6
console.log(randomNumber(3,-1)); # 1 3 1 -1 -1 -1

Depois de gerar um número aleatório usando um programa de computador, ele ainda é considerado como um número aleatório se o número escolhido é uma parte ou o completo Um do inicial. Mas se foi mudado, então os matemáticos não o aceitam como um número aleatório e podem chamá-lo de um número tendencioso. mas se você está desenvolvendo um programa para uma tarefa simples, este não será um caso a considerar. mas se você está desenvolvendo um programa para gerar um número aleatório para um material valioso como programa de loteria, ou jogo de jogo, em seguida, o seu programa será rejeitado pela gerência se você não é considerado sobre o caso acima.

Gerar um número aleatório usando Math.random().(say this n)

Now for [0,10) ==>  n*10 (i.e. one digit) and for[10,100) ==> n*100 (i.e. two digits) and so on. Here squire bracket indicates that boundary is inclusive and round bracket indicates boundary is exclusive.
Then remove the rest after the decimal point. (i.e. get floor) - using Math.floor(), this can be done.

Se você sabe como ler a tabela de números aleatórios para escolher um número aleatório, Você sabe acima processo (multiplicando por 1, 10, 100 e assim por diante) não viola o que eu fui mencionado no início.(Porque altera apenas a casa decimal.)

Estude o seguinte exemplo e desenvolva-o de acordo com as suas necessidades.

Se precisar de uma amostra [0,9], o piso de n*10 é a sua resposta e, se necessário [0,99], o piso de n*100 é a sua resposta e assim por diante.

Agora vamos entrar no seu papel:

Você perguntou números entre o alcance específico. (Neste caso, você é tendenciosa entre essa faixa. - Ao tirar um número de [1,6] rolando um dado, então você é parcial em [1,6] mas ainda é um Aleatório se e somente se morrer é imparcial.)

Por isso, considere o seu intervalo = > [78, 247] número de elementos da Gama = 247 - 78 + 1 = 170; (já que ambos os limites são inclusivos.

/*Mthod 1:*/
    var i = 78, j = 247, k = 170, a = [], b = [], c, d, e, f, l = 0;
    for(; i <= j; i++){ a.push(i); }
    while(l < 170){
        c = Math.random()*100; c = Math.floor(c);
        d = Math.random()*100; d = Math.floor(d);
        b.push(a[c]); e = c + d;
        if((b.length != k) && (e < k)){  b.push(a[e]); }
        l = b.length;
    }
    console.log('Method 1:');
    console.log(b);
/*Method 2:*/

    var a, b, c, d = [], l = 0;
    while(l < 170){
        a = Math.random()*100; a = Math.floor(a);
        b = Math.random()*100; b = Math.floor(b);
        c = a + b;
        if(c <= 247 || c >= 78){ d.push(c); }else{ d.push(a); }
        l = d.length;
    }
    console.log('Method 2:');
    console.log(d);

Em ambos os métodos, a sua consola irá mostrar o resultado.(Pressione f12 no Chrome para abrir a consola)

Para um inteiro aleatório com um intervalo, tente:

function random(minimum, maximum) {
  var bool = true;

  while (bool) {
    var number = (Math.floor(Math.random() * maximum + 1) + minimum);
    if (number > 20) {
      bool = true;
    } else {
      bool = false;
    }
  }

  return number;
}

Aqui está a implementação do MS DotNet de classe aleatória em javascript -

var Random = (function () {
function Random(Seed) {
    if (!Seed) {
        Seed = this.milliseconds();
    }
    this.SeedArray = [];
    for (var i = 0; i < 56; i++)
        this.SeedArray.push(0);
    var num = (Seed == -2147483648) ? 2147483647 : Math.abs(Seed);
    var num2 = 161803398 - num;
    this.SeedArray[55] = num2;
    var num3 = 1;
    for (var i_1 = 1; i_1 < 55; i_1++) {
        var num4 = 21 * i_1 % 55;
        this.SeedArray[num4] = num3;
        num3 = num2 - num3;
        if (num3 < 0) {
            num3 += 2147483647;
        }
        num2 = this.SeedArray[num4];
    }
    for (var j = 1; j < 5; j++) {
        for (var k = 1; k < 56; k++) {
            this.SeedArray[k] -= this.SeedArray[1 + (k + 30) % 55];
            if (this.SeedArray[k] < 0) {
                this.SeedArray[k] += 2147483647;
            }
        }
    }
    this.inext = 0;
    this.inextp = 21;
    Seed = 1;
}
Random.prototype.milliseconds = function () {
    var str = new Date().valueOf().toString();
    return parseInt(str.substr(str.length - 6));
};
Random.prototype.InternalSample = function () {
    var num = this.inext;
    var num2 = this.inextp;
    if (++num >= 56) {
        num = 1;
    }
    if (++num2 >= 56) {
        num2 = 1;
    }
    var num3 = this.SeedArray[num] - this.SeedArray[num2];
    if (num3 == 2147483647) {
        num3--;
    }
    if (num3 < 0) {
        num3 += 2147483647;
    }
    this.SeedArray[num] = num3;
    this.inext = num;
    this.inextp = num2;
    return num3;
};
Random.prototype.Sample = function () {
    return this.InternalSample() * 4.6566128752457969E-10;
};
Random.prototype.GetSampleForLargeRange = function () {
    var num = this.InternalSample();
    var flag = this.InternalSample() % 2 == 0;
    if (flag) {
        num = -num;
    }
    var num2 = num;
    num2 += 2147483646.0;
    return num2 / 4294967293.0;
};
Random.prototype.Next = function (minValue, maxValue) {
    if (!minValue && !maxValue)
        return this.InternalSample();
    var num = maxValue - minValue;
    if (num <= 2147483647) {
        return parseInt((this.Sample() * num + minValue).toFixed(0));
    }
    return this.GetSampleForLargeRange() * num + minValue;
};
Random.prototype.NextDouble = function () {
    return this.Sample();
};
Random.prototype.NextBytes = function (buffer) {
    for (var i = 0; i < buffer.length; i++) {
        buffer[i] = this.InternalSample() % 256;
    }
};
return Random;
}());

Utilização:

        var r = new Random();
        var nextInt = r.Next(1, 100); //returns an integer between range
        var nextDbl = r.NextDouble(); //returns a random decimal

Se necessitar de uma variável entre 0 e o máximo pode utilizar:

Math.floor(Math.random() *  max);

    0.5 + (Math.random() * ((6 - 1) + 1))

Isto multiplica um número aleatório por 6 e depois adiciona-lhe 0,5. Próximo round o número para um inteiro positivo, fazendo:

    Math.round(0.5 + (Math.random() * ((6 - 1) + 1))

Este arredondado o número para o número inteiro mais próximo.

Ou para que seja mais compreensível fazer isto:

    var value = 0.5 + (Math.random() * ((6 - 1) + 1))
    var roll = Math.round(value);
    return roll;

Em geral, o código para fazer isto usando variáveis é:

    var value = (Min - 0.5) + (Math.random() * ((Max - Min) + 1))
    var roll = Math.round(value);
    return roll;

A razão para retirar 0, 5 do valor mínimo é porque se utiliza o valor mínimo o valor sozinho permitiria que você começ um inteiro que era um a mais do que seu valor máximo. Ao retirar 0,5 do valor mínimo, está essencialmente a impedir que o valor máximo seja arredondado.

Espero que isso ajude.

Se usar o seguinte código, poderá gerar uma série de números aleatórios, sem repetir, num dado intervalo.

function genRandomNumber(how_many_number,min,max) {

            // parameters
            // how_many_number : how many numbers you want to generate. For example it is 5.
            // min(inclusive) : minimum/low value of a range. it must be any positive integer but less than max. i.e 4
            // max(inclusive) : maximun value of a range. it must be any positive integer. i.e 50
            // return type: array

            var random_number = [];
            for (var i = 0; i < how_many_number; i++) {
                var gen_num = parseInt((Math.random() * (max-min+1)) + min);
                do {
                    var is_exist = random_number.indexOf(gen_num);
                    if (is_exist >= 0) {
                        gen_num = parseInt((Math.random() * (max-min+1)) + min);
                    }
                    else {
                        random_number.push(gen_num);
                        is_exist = -2;
                    }
                }
                while (is_exist > -1);
            }
            document.getElementById('box').innerHTML = random_number;
        }

Número inteiro aleatório entre o mais baixo e o mais alto:

function randomRange(l,h){
  var range = (h-l);
  var random = Math.floor(Math.random()*range);
  if (random === 0){random+=1;}
  return l+random;
}

Encontrei este método simples em W3Schools:

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

function random(high,low) {
    high++;
    return Math.floor((Math.random())*(high-low))+low;
}

Executamos high++ Porque Math.random() gera um número aleatório entre 0, (inclusivo), e 1(exclusivo) o que está a ser excluído, significa que temos de aumentar o alto por um antes de executar qualquer matemática. Em seguida, subtrai - se baixo de alto, dando-nos o número mais alto para gerar-baixo, em seguida, mais baixo, trazendo alto de volta ao normal, e tornando o número mais baixo pelo menos baixo baixo. então nós retornamos o número resultante

random(7,3) pode voltar 3,4,5,6, or 7

    <!DOCTYPE html>
<html>
    <head>
            <meta charset="utf-8" />
    </head>
    <body>
        <script>
            /*

                assuming that window.crypto.getRandomValues is available
                the real range would be fron 0 to 1,998 instead of 0 to 2,000
                See javascript documentation for explanation
                https://developer.mozilla.org/en-US/docs/Web/API/RandomSource/getRandomValues
            */
            var array = new Uint8Array(2);
            window.crypto.getRandomValues(array);
            console.log(array[0] + array[1]);

        </script>
    </body>
</html>

Uint8Array criar um array cheio com um número até 3 dígitos que seria um máximo de 999. Este código é muito curto.

Se ajuda a usá-lo, aqui está:

// get random number within provided base + exponent
// by Goran Biljetina --> 2012

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}
var numSeq = new Array();
function add(num,seq){
    var toAdd = new Object();
     toAdd.num = num;
     toAdd.seq = seq;
     numSeq[numSeq.length] = toAdd;
}
function fillNumSeq (num,seq){
    var n;
    for(i=0;i<=seq;i++){
        n = Math.pow(num,i);
        add(n,i);
    }
}
function getRandNum(base,exp){
    if (isEmpty(base)){
        console.log("Specify value for base parameter");
    }
    if (isEmpty(exp)){
        console.log("Specify value for exponent parameter");
    }
    fillNumSeq(base,exp);
    var emax;
    var eseq;
    var nseed;
    var nspan;
    emax = (numSeq.length);
    eseq = Math.floor(Math.random()*emax)+1;
    nseed = numSeq[eseq].num;
    nspan = Math.floor((Math.random())*(Math.random()*nseed))+1;
    return Math.floor(Math.random()*nspan)+1;
}

console.log(getRandNum(10,20),numSeq);
//testing:
//getRandNum(-10,20);
//console.log(getRandNum(-10,20),numSeq);
//console.log(numSeq);

    function genRandom(length)
    {
     const t1 = new Date().getMilliseconds();
     var min = "1",max = "9";
     var result;
     var numLength = length;
     if (numLength != 0)
     {
        for (var i = 1; i < numLength; i++)
        {
           min = min.toString() + "0";
           max = max.toString() + "9";
        }
     } 
     else
     {
        min = 0;
        max = 0;
        return; 
     }

      for (var i = min; i <= max; i++)
      {
           //Empty Loop
      }

      const t2 = new Date().getMilliseconds();
      console.log(t2);
      result = ((max - min)*t1)/t2;
      console.log(result);
      return result;
    }

function getRandomInt(lower, upper)
{
    //to create an even sample distribution
    return Math.floor(lower + (Math.random() * (upper - lower + 1)));

    //to produce an uneven sample distribution
    //return Math.round(lower + (Math.random() * (upper - lower)));

    //to exclude the max value from the possible values
    //return Math.floor(lower + (Math.random() * (upper - lower)));
}

Para testar esta função, e variações desta função, salve o HTML/JavaScript abaixo para um arquivo e abra com um navegador. O código produzirá um gráfico mostrando a distribuição de um milhão de chamadas de funções. O código também registrará os casos de bordas, então se a função produzir um valor maior que o máximo, ou menor que o min, you.will.know.about.it.

<html>
    <head>
        <script type="text/javascript">
        function getRandomInt(lower, upper)
        {
            //to create an even sample distribution
            return Math.floor(lower + (Math.random() * (upper - lower + 1)));

            //to produce an uneven sample distribution
            //return Math.round(lower + (Math.random() * (upper - lower)));

            //to exclude the max value from the possible values
            //return Math.floor(lower + (Math.random() * (upper - lower)));
        }

        var min = -5;
        var max = 5;

        var array = new Array();

        for(var i = 0; i <= (max - min) + 2; i++) {
          array.push(0);
        }

        for(var i = 0; i < 1000000; i++) {
            var random = getRandomInt(min, max);
            array[random - min + 1]++;
        }

        var maxSample = 0;
        for(var i = 0; i < max - min; i++) {
            maxSample = Math.max(maxSample, array[i]);
        }

        //create a bar graph to show the sample distribution
        var maxHeight = 500;
        for(var i = 0; i <= (max - min) + 2; i++) {
            var sampleHeight = (array[i]/maxSample) * maxHeight;

            document.write('<span style="display:inline-block;color:'+(sampleHeight == 0 ? 'black' : 'white')+';background-color:black;height:'+sampleHeight+'px">&nbsp;[' + (i + min - 1) + ']:&nbsp;'+array[i]+'</span>&nbsp;&nbsp;');
        }
        document.write('<hr/>');
        </script>
    </head>
    <body>

    </body>
</html>

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

Isto consegue gerar um número aleatório único de 20 dígitos

JS

var generatedNumbers = [];

function generateRandomNumber(precision) { // precision --> number precision in integer 
    if (precision <= 20) {
        var randomNum = Math.round(Math.random().toFixed(precision) * Math.pow(10, precision));
        if (generatedNumbers.indexOf(randomNum) > -1) {
            if (generatedNumbers.length == Math.pow(10, precision))
                return "Generated all values with this precision";
                return generateRandomNumber(precision);
        } else {
            generatedNumbers.push(randomNum);
            return randomNum;
        }
    } else
       return "Number Precision shoould not exceed 20";
}
generateRandomNumber(1);

JsFiddle

/* Escreva uma função chamada randUpTo que aceita um número e devolve um um número aleatório entre 0 e esse número? */

var randUpTo = function(num) {
    return Math.floor(Math.random() * (num - 1) + 0);
};

/* Escreva uma função chamada randBetween que aceita dois números representa um intervalo e devolve um número inteiro aleatório entre esses dois numero. */

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

/* Escreva uma função chamada randFromTill que aceita dois números representa um intervalo e devolve um número aleatório entre min (inclusive) e max (exclusivo). */

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

/* Escreva uma função chamada randFromTo que aceita dois números representando um intervalo e devolve um inteiro aleatório entre o min (inclusive) e max (inclusive) */

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

Solução Alternativa: -

let makeGuess = function(guess){
    let min = 1;
    let max = 5;   
    let randomNumber = Math.floor(Math.random() * (max - min + 1)) + min

    return guess === randomNumber;

}
console.log(makeGuess(1));

E também para verificar se essa distribuição seria mais ou menos a mesma nos diferentes navegadores.

function getRandomNumberInRange(Min, Max) {
    return Math.floor(Math.random() * (Max - Min + 1)) + Min;
}

function printDictAsTable(dict){
   let htmlstr = "<table border=1><tr><th>Number</th><th>Count</th></tr>";
   
   let sortedKeys = Object.keys(dict).sort(function(a,b){return a-b});

   for (let i=0; i<sortedKeys.length; i++) {
     let key = sortedKeys[i];
     htmlstr += "<tr><td>"+ key +" </td><td>" + dict[key] + " </td></tr>";
   }
   htmlstr += "</table>";
   document.getElementById("tableContainer").innerHTML = htmlstr;
}

function loopRandomAndPrint(){
    let min = Number(document.getElementById("randomMinLimit").value);
    let max = Number(document.getElementById("randomMaxLimit").value);
    if (max < min){let temp = max; max = min; min = temp;}
    let loopTotal = Number(document.getElementById("loopLimit").value);
    let dict = {};
    
    for(i = min; i <= max; ++i){
        dict[i] = 0;
    }

    for(i = 0; i < loopTotal; i++){
        let num = getRandomNumberInRange(min, max);
        dict[num] = dict[num] + 1;
    }
    
    printDictAsTable(dict);
}

loopRandomAndPrint();

<div id="topContainer">
<div id="inputAndButton" style="float: left;">
<p>Min  : <input type="number" id="randomMinLimit" value=4></p>
<p>Max  : <input type="number" id="randomMaxLimit" value=8></p>
<p>Loops: <input type="number" id="loopLimit" value=1000></p>
<button type="button" onclick="loopRandomAndPrint()">
Loop random function and show </button>
</div>
<div id="tableContainer" style="float: right;">
</div>
</div>