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

математика.random ()

С Mozilla документация по сети разработчиков:

// 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, мы получим двойной где-то между 0 и 1+b-a.

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

Math.floor округляет число до ближайшего целого числа. Итак, теперь у нас есть все целые числа между 0 и top-bottom. 1 выглядит запутанным, но он должен быть там, потому что мы всегда округляем вниз, поэтому верхнее число никогда не будет на самом деле можно достичь и без него. Случайная десятичная мы генерируем должен быть в диапазоне 0 to (1+top-bottom) таким образом, мы можем округлить и получить int в диапазоне 0 to 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
}

Если вы используете подчеркивания.js можно использовать

_.random(min, max)

другие ответы не учитывают совершенно разумные параметры 0 и 1. Вместо этого вы должны использовать round of 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);

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

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

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

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

вот реализация MS DotNet случайного класса в 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

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

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

чтобы получить случайное число между 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 от минимального значения, вы по существу предотвращаете округление максимального значения.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Это мой взгляд на случайное число в диапазоне, так как я хотел получить случайное число в диапазоне от базы до экспоненты. например, 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);

Эй, ребята, я создал функцию javascript, такую же, как Math.random (), с помощью которого мы можем генерировать случайных чисел!--3--> of любая заданная длина. Без использования каких-либо математика.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;
    }

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, вы.Уилл.знаю.около.это.

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

Это может обрабатывать генерирование до 20-значного уникального случайного числа

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

/* Напишите функцию 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 (включительно) и Макс (эксклюзивный.) */

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

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

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

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

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

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

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

Итак, вот фрагмент для запуска. Номера могут быть изменены перед нажатием кнопки.

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>