Як я можу генерувати випадкові цілі числа між двома вказаними змінними в JavaScript, наприклад, x = 4і чи y = 8буде виводити будь-яку з 4, 5, 6, 7, 8?

На сторінці мережі розробників Mozilla є кілька прикладів :

/**
 * Returns a random number between min (inclusive) and max (exclusive)
 */
function getRandomArbitrary(min, max) {
    return Math.random() * (max - min) + min;
}

/**
 * Returns a random integer between min (inclusive) and max (inclusive).
 * The value is no lower than min (or the next integer greater than min
 * if min isn't an integer) and no greater than max (or the next integer
 * lower than max if max isn't an integer).
 * Using Math.round() will give you a non-uniform distribution!
 */
function getRandomInt(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

Ось логіка за цим. Це просте правило з трьох:

Math.random()повертає Numberміж 0 (включно) і 1 (виключно). Отже, у нас такий інтервал:

[0 .................................... 1)

Тепер ми хотіли б число між min(включно) та max(ексклюзивно):

[0 .................................... 1)
[min .................................. max)

Ми можемо скористатися значком Math.randomдля отримання кореспондента в інтервалі [хв, макс.). Але, спершу слід трохи задати проблему, віднімаючи minз другого інтервалу:

[0 .................................... 1)
[min - min ............................ max - min)

Це дає:

[0 .................................... 1)
[0 .................................... max - min)

Тепер ми можемо подати заявку Math.randomта обчислити кореспондента. Виберемо випадкове число:

                Math.random()
                    |
[0 .................................... 1)
[0 .................................... max - min)
                    |
                    x (what we need)

Отже, щоб знайти x, ми зробили б:

x = Math.random() * (max - min);

Не забудьте додати minназад, щоб ми отримали число в інтервалі [min, max):

x = Math.random() * (max - min) + min;

Це була перша функція від MDN. Другий - повертає ціле число між, minі maxобидва включно.

Тепер для отримання цілих чисел, ви могли б використовувати round, ceilабо floor.

Ви можете використовувати Math.round(Math.random() * (max - min)) + min, але це дає нерівномірний розподіл. І те, minі maxлише приблизно половина шансів прокататись:

min...min+0.5...min+1...min+1.5   ...    max-0.5....max
└───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘   ← Math.round()
   min          min+1                          max

Якщо maxвиключатися з інтервалу, він має ще менший шанс скотитися, ніж min.

З Math.floor(Math.random() * (max - min +1)) + minвами ідеально рівномірний розподіл.

min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval)
|        |        |         |        |        |
└───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘   ← Math.floor()
   min     min+1               max-1    max

Ви не можете використовувати ceil()і -1в цьому рівнянні, тому що maxтепер було трохи менше шансів прокатитися, але ви також можете скочувати (небажаний) min-1результат.

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

Math.random ()

Повертає ціле випадкове число між min ( включено ) та max ( включено ):

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

Або будь-яке випадкове число між min ( включено ) та max ( не включено ):

function randomNumber(min, max) {
  return Math.random() * (max - min) + 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;

** І завжди приємно нагадувати (Mozilla):

Math.random () не забезпечує криптографічно захищених випадкових чисел. Не використовуйте їх для нічого, що стосується безпеки. Замість цього скористайтеся API Web Crypto, а точніше методом window.crypto.getRandomValues ​​().

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щоб (1+top-bottom)ми могли округлити і отримати цілу точку в діапазоні 0доtop-bottom

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

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

ПРИМІТКА: Якщо ви перейдете в ціле значення або більше число, спочатку ви отримаєте небажану поведінку, але якщо хтось цього не вимагає, я не збираюся заглиблюватися в код перевірки аргументів як його досить далекий від наміру вихідного питання .

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

Альтернативно, якщо ви використовуєте Underscore.js, який ви можете використовувати

_.random(min, max)

Повернути випадкове число між 1 і 10:

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

Повернути випадкове число між 1 і 100:

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

Якщо вам потрібна величина між 0 і макс, ви можете використовувати:

Math.floor(Math.random() *  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

Ось реалізація класу 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 rnd(min,max){
    return Math.floor(Math.random()*(max-min+1)+min );
}

Після генерації випадкового числа за допомогою комп’ютерної програми воно все ще вважається випадковим числом, якщо вибране число є частиною або повним - початковим. Але якщо це було змінено, то математики не сприймають його як випадкове число, і вони можуть назвати це упередженим числом. Але якщо ви розробляєте програму для простого завдання, це не буде справою. Але якщо ви розробляєте програму для генерування випадкових цифр для таких цінних речей, як програма лотереї чи гра в азартні ігри, то ваша програма буде відхилена керівництвом, якщо ви не враховуєте вищевказаний випадок.

Отже, для таких людей, ось моя пропозиція:

Створіть випадкове число, використовуючи 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, щоб відкрити консоль)

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

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 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 у файлі та відкрийте за допомогою браузера. Код створить графік, що показує розподіл мільйона функціональних викликів. Код також записуватиме крайові регістри, тому якщо функція створює значення, що перевищує максимум або менше, ніж мінімум, ви.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>

Щоб отримати випадкове число, скажімо, від 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;
        }

Я знаю, що на це питання вже відповіли, але моя відповідь могла б комусь допомогти.

Я знайшов цей простий метод у 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 створить масив, заповнений цифрою до 3 цифр, що буде максимум 999. Цей код дуже короткий.

Ось приклад функції 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;
    }

це моє взяття на випадкове число в діапазоні, так як я хотів отримати випадкове число в діапазоні від бази до показника. наприклад, база = 10, експонент = 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);

Math.random() швидко і підходить для багатьох цілей, але це не доречно, якщо вам потрібні криптографічно захищені значення (це не захищено) або якщо вам потрібні цілі числа з цілком рівномірного неупередженого розподілу (підхід множення, який використовується в інших відповідях, дає певні значення трохи частіше ніж інші).

У таких випадках ми можемо використовувати crypto.getRandomValues() для створення захищених цілих чисел та відхиляти будь-які згенеровані значення, які ми не можемо рівномірно відобразити у цільовий діапазон. Це буде повільніше, але воно не повинно бути суттєвим, якщо ви не генеруєте надзвичайно велику кількість значень.

Для уточнення проблеми з упередженим розподілом розглянемо випадок, коли ми хочемо генерувати значення від 1 до 5, але у нас є генератор випадкових чисел, який виробляє значення між 1 і 16 (4-бітове значення). Ми хочемо, щоб однакове число згенерованих значень відображалося на кожне вихідне значення, але 16 не ділиться рівно на 5: воно залишає залишок 1. Отже, нам потрібно відхилити 1 можливих згенерованих значень і продовжувати лише тоді, коли отримаємо одне з 15 менших значень, яке можна рівномірно відобразити в нашому цільовому діапазоні. Наша поведінка може виглядати приблизно так:

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.

У наведеному нижче коді використовується аналогічна логіка, але натомість генерується 32-бітове ціле число, оскільки це найбільший загальний розмір цілих чисел, який може бути представлений стандартним numberтипом JavaScript . (Це може бути змінено для використання BigInts, якщо вам потрібен більший діапазон.) Незалежно від обраного діапазону, частка генерованих значень, які відхиляються, завжди буде менше 0,5, тому очікувана кількість відхилень завжди буде менше 1,0 і зазвичай близький до 0,0; вам не потрібно турбуватися про це петлі назавжди.

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]

Криптовалюта

Щоб отримати крипто-сильне випадкове ціле число в ragne [x, y], спробуйте

let cs= (x,y)=>x+(y-x+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0

console.log(cs(4,8))

Ви можете цей фрагмент коду,

let randomNumber = function(first,second){
let number = Math.floor(Math.random()*Math.floor(second));
while(number<first){

    number = Math.floor(Math.random()*Math.floor(second));
}
return number;
}

Ionuț G. Stan написав чудову відповідь, але для мене це було занадто складно. Отже, я знайшов ще простіше пояснення тих же понять на https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation by Джейсон Анелло.

ПРИМІТКА . Єдине важливе, що ви повинні знати, перш ніж прочитати пояснення Джейсона, - це визначення "усікати". Він використовує цей термін при описі Math.floor(). Оксфордський словник визначає "усікати" як:

Скоротіть (щось), відрізавши верх або кінець.

Це може впоратися з генеруванням до 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 (включно) та 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;
};

Я зробив цю функцію, яка враховує такі параметри, як min, max, виключити (список входів, які потрібно виключити), і насіннєві (на випадок, якщо ви хочете посіяти випадковий генератор).

get_random_int = function(args={})
{
    let def_args =
    {
        min: 0,
        max: 1,
        exclude: false,
        seed: Math.random
    }

    args = Object.assign(def_args, args)

    let num = Math.floor(args.seed() * (args.max - args.min + 1) + args.min)

    if(args.exclude)
    {
        let diff = args.max - args.min
        let n = num

        for(let i=0; i<diff*2; i++)
        {
            if(args.exclude.includes(n))
            {
                if(n + 1 <= args.max)
                {
                    n += 1
                }

                else
                {
                    n = args.min
                }
            }

            else
            {
                num = n
                break
            }
        }
    }

    return num
}

Його можна використовувати так:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1,
        exclude: [3, 6, 5],
        seed: my_seed_function
    }
)

Або простіше:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1
    }
)

Тоді ви можете зробити:

let item = some_list[n]

Суть: https://gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e

• випадкове (min, max) генерує випадкове число між min (включно) та max (виключно)

• Math.floor округляє число до найближчого цілого числа

  function generateRandomInteger (min, max) { 
      return Math.floor(random(min,max)) 
  }`

Отже, щоб генерувати випадкове ціле число між 4 і 8 включно, викликайте вищевказану функцію за допомогою таких аргументів:

generateRandomInteger (4,9)

Мій метод генерації випадкових чисел між 0 і n, де n <= 10 (n виключено):

Math.floor((Math.random() * 10) % n)