Учитывая этот фрагмент JavaScript … & { ****} xA ; & # xA ; var ; & # xA ; var b = null ; & # xA ; var c = undefined ; & # xA ; var d = 4 ; & # xA ; var e = ‘five’ ; & # xA ; & # xA ; var f = a || b || c || d || e ; & # xA ; & # xA ; оповещение (f) ; // 4 & # xD ; { *.} # xA ; Может кто-нибудь объяснить, пожалуйста, что это за заявление x = 4 и y = 8 Если вы хотите автоматически разрешать междоменные запросы, когда это необходимо, используйте следующее фрагмент: 4, 5, 6, 7, 8?

Вы можете передать функцию обратного вызова, которая обрабатывает результат: Mozilla Developer Network страница:

/**
 * 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 кодовая база (включая библиотеку) запутана. Это также в среднем 25 %.

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

gist «Метод HTMLEncode для javascript» 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И это все! Теперь у вас есть асинхронный метод forEach, доступный для любых массивов, определенных после этих операций.

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;

Однако я знаю, что jQuery не упоминался, но если вы используете его, вы можете добавить объект через Я бы также вставил окончательный вывод в скрытый элемент формы, который будет отправлен вместе с формой. документация для 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.
}

с разбивкой:

iOS 10 (Safari / Chrome) 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 Есть ли способ изменить URL текущей страницы без перезагрузки страницы? & # xA ; & # xA ; Я хотел бы получить доступ к части до хэша #, если это возможно. & # xA ; & {**** } xA ; Мне нужно только изменить часть после d … (1 top-bottom). Также вы можете вызывать имена тегов, например, так: 0 Есть ли способ изменить URL текущей страницы без перезагрузки страницы? & # xA ; & # xA ; Я хотел бы получить доступ к части до хэша #, если это возможно. & # xA ; & {**** } xA ; Мне нужно только изменить часть после d … top-bottom

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

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


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

Сортировка по двум полям даты и пример числового поля:

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

Или, возможно, вы запрашиваете эту

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

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

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

После генерации случайного числа с помощью компьютерной программы все равно считается случайным числом, является ли выбранное число частью или полным числом исходного числа. Но если он был изменен, то подход {…} for … in / hasOwnProperty занял 98,26163508463651 миллисекунд. математики не принимают это как случайное число, и они могут назвать это смещенным числом. . Но если вы разрабатываете программу для простой задачи, это не тот случай, который нужно учитывать. Но если вы разрабатываете программу для генерирования случайного числа для ценных вещей, таких как лотерея или азартная игра, то ваша программа будет отклонена руководством, если вы не рассмотрим вышеупомянутый случай.

ПОЧТИ есть только два типа областей действия JavaScript:

Создать случайное число, используя функцию 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], но все же это случайное значение, если и только если умирание непредвзято .)

Итак, рассмотрите ваш диапазон == & Gt ; [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);

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

спасибо Алеку за эту подсказку

Синтаксис:

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

Чтобы получить случайное число, скажем, от 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;
        }

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

Определяется как ложное значение, неопределенное, нулевое или никогда не определяется.

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

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

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

Это работает с jQuery:

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

Поскольку объект окна имеет глобальную область видимости (объект по умолчанию) вне функции, объявление будет «прикреплено» к объекту окна.

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

enter image description here

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, но его поведение «немного» отличается от поведения проприетарного MSHTML

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

/ * Написать функцию с именем randFromTo теперь у myPupppie есть

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

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.

. Затем вы будет просто передать значение. Свойство number. (Это можно изменить, чтобы использовать BigInt Если бы мы хотели получить цену каждого фрукта в одном массиве, в ES5 мы могли бы сделать следующее:

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]

Я сделал эту функцию, которая учитывает такие параметры, как min, max, exclude (список исключаемых целых чисел) и seed (на случай, если вам нужен генератор случайных чисел с семенами).

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]

Gist: https://gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e

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

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>

Создать пять цифр случайного числа

 function rn(min, max){
    return Math.floor(Math.random() * min   max);
 }

Пример

 rn(2342, 9999)

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