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

Math.random()

Из документации Mozilla Developer Network:

// Returns a random integer between min (include) and max (include)

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

Полезные примеры:

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

использование:

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.
}

разбивка:

Мы возвращаем функцию (заимствование из функционального программирования), которая при вызове возвращает случайное целое число между значениями bottom и top, включительно. Мы говорим "включительно", потому что мы хотим включить как нижний, так и верхний в диапазон чисел, которые можно вернуть. Таким образом, getRandomizer( 1, 6 ) вернет либо 1, 2, 3, 4, 5, либо 6.

(нижнее нижнее число, верхнее - большее число)

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

Math.random() возвращает случайный двойник между 0 и 1, и если мы умножим его на единицу плюс разницу между top и bottom, мы получим double где-то между 0 и 1+b-a.

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

Math.floor округляет число до ближайшего целого. Итак, теперь мы имеем все целые числа между 0 и top-bottom. 1 выглядит сбивающим с толку, но он должен быть там, потому что мы всегда округляем, поэтому верхнее число никогда не будет достигнуто без него. Производящееся десятичное число, которое мы генерируем, должно находиться в диапазоне от 0 до (1+top-bottom), поэтому мы можем округлить и получить int в диапазоне от 0 до top-bottom

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

Код в предыдущем примере дал нам целое число в диапазоне 0 и top-bottom, поэтому все, что нам нужно сделать, это добавить bottom к этому результату, чтобы получить целое число в диапазоне bottom и top включительно.: D

ПРИМЕЧАНИЕ. Если вы передадите не целое значение или большее число, вы получите нежелательное поведение, но, если кто-либо его не попросит, я не буду вникать в код проверки аргументов, поскольку он довольно далек от намерения оригинальный вопрос.

Возвращает случайное число от 1 до 10:

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

Возвращает случайное число от 1 до 100:

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

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

Альтернативно, если вы используете Underscore.js, вы можете использовать

_.random(min, max)

В других ответах не учитываются вполне разумные параметры 0 и 1. Вместо этого вместо round вместо используйте ceil или 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

После создания случайного числа с использованием компьютерной программы он по-прежнему считается случайным числом, если выбранное число является частью или полным из исходного. Но если он был изменен, то математики не принимают его как случайное число, и они могут называть его предвзятым числом. Но если вы разрабатываете программу для простой задачи, это не будет случай рассматривать. Но если вы разрабатываете программу для генерации случайного числа для ценного материала, такого как лотерейная программа или игра в азартные игры, тогда ваша программа будет отклонена руководством, если вы не будете рассматривать этот случай.

Итак, для тех людей, вот мое предложение:

Создайте случайное число, используя Math.random() (скажем, это 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.

Если вы знаете, как читать таблицу случайных чисел, чтобы выбрать случайное число, вы знаете выше процесс (умножение на 1, 10, 100 и т.д.) не нарушает тот, который я упоминал в начале. (Потому что это изменяет только место десятичной точки.)

Изучите следующий пример и разработайте его для ваших нужд.

Если вам нужен образец [0,9], то пол n * 10 - ваш ответ, и если вам нужно [0,99], то пол n * 100 - ваш ответ и т.д.

Теперь введите свою роль:

Вы запросили номера среди определенного диапазона. (В этом случае вы смещены в этом диапазоне. - Приняв число из [1,6], свернув кубик, вы пристраститесь к [1,6], но все же это случайный случай, если и только если смерть непредвзята.)

Итак, рассмотрим ваш диапазон == > [78, 247] количество элементов диапазона = 247 - 78 + 1 = 170; (так как обе границы включены.

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

Примечание. Сначала в первом методе я создал массив, который содержит нужные вам числа, а затем случайным образом помещает их в другой массив. В способе два, произвольно генерируйте числа и проверяйте их в том диапазоне, который вам нужен. Затем поместите его в массив. Здесь я сгенерировал два случайных числа и использовал их для максимизации скорости программы, минимизируя частоту отказов, получая полезное число. Однако добавление сгенерированных чисел также даст некоторую предвзятость. Поэтому я бы рекомендовал мой первый метод генерировать случайные числа в определенном диапазоне.

В обоих методах ваша консоль покажет результат. (Нажмите кнопку f12 в Chrome, чтобы открыть консоль)

Если вам нужна переменная между 0 и max, вы можете использовать:

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

Вот MS DotNet Внедрение класса Random в 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;
}());

Применение:

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

Для случайного целого с диапазоном, попробуйте:

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

Используя следующий код, вы можете генерировать массив случайных чисел без повторения в заданном диапазоне.

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

Чтобы получить случайное число, скажем, между 1 и 6, сначала выполните:

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

Это умножает случайное число на 6 и затем добавляет к нему 0.5. Затем округлите число до положительного целого числа, выполнив:

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

Это округляет число до ближайшего целого числа.

Или, чтобы сделать это более понятным, выполните следующее:

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

В общем случае код для этого с использованием переменных:

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

Причиной отнять 0,5 от минимального значения является то, что использование только минимального значения позволит вам получить целое число, которое было бы больше вашего максимального значения. Убрав 0,5 от минимального значения, вы по существу предотвращаете округление максимального значения.

Надеюсь, что это поможет.

Я знаю, что этот вопрос уже ответил, но мой ответ может помочь кому-то.

Я нашел этот простой метод в W3Schools:

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

Надеюсь, это поможет кому-то.

Случайное целое число между самым низким и самым высоким:

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

Не самое элегантное решение.. но что-то быстрое.

Здесь я использую для генерации случайных чисел.

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

Мы выполняем high++, потому что Math.random() генерирует случайное число между 0, (включительно) и 1 (исключение). Исключенный, означает, что мы должны увеличивать максимум на один до выполнения любой математики. Затем мы вычитаем низкое значение из максимума, давая нам наибольшее число для генерации - низкое, затем + низкое, что приводит к возврату в нормальное состояние и делает наименьшее число по крайней мере низким. то мы возвращаем результирующее число

random(7,3) может вернуться 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 создает массив, заполненный числом до трех цифр, которое должно быть не более 999. Этот код очень короткий.

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

Вот пример функции javascript, которая может генерировать случайное число любой указанной длины без использования Math.random():

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

это мой выбор случайного числа в диапазоне, так как я хотел получить случайное число в диапазоне от базового до экспоненты. например base = 10, exponent = 2, дает случайное число от 0 до 100, в идеале и т.д.

если он помогает использовать его, вот он:

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

Чтобы проверить эту функцию и варианты этой функции, сохраните ниже HTML/JavaScript в файл и откройте его в браузере. В коде будет показан график, показывающий распределение одного миллиона вызовов функций. Код также будет записывать случаи краев, поэтому, если функция вырабатывает значение, большее, чем max, или меньше, чем 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 rn(min, max){
    return Math.floor(Math.random() * min + max);
 }

пример

 rn(2342, 9999)

Надеюсь, поможет

Мне стало интересно, каким будет распределение после достаточного количества прогонов для такой функции рандомизатора.

А также проверить, будет ли это распределение более или менее одинаковым в разных браузерах.

Так что здесь фрагмент для запуска. Цифры могут быть изменены до нажатия кнопки.

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>

Альтернативное решение: -

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

/* Написать функцию с именем randUpTo которая принимает число и возвращает случайное целое число от 0 до этого числа? */

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

/* Напишите функцию с именем randBetween которая принимает два числа, представляющих диапазон, и возвращает случайное целое число между этими двумя числами. */

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

/* Напишите функцию с именем randFromTill которая принимает два числа, представляющих диапазон, и возвращает случайное число между min (включительно) и max (эксклюзивом). */

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

/* Напишите функцию с именем randFromTo которая принимает два числа, представляющих диапазон, и возвращает случайное целое число от min (включительно) до max (включительно) */

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

Это может обрабатывать генерирование до 20 цифр UNIQUE случайных чисел

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