在JavaScript中生成特定范围内的随机整数？

Question

如何在Javascript中的两个指定变量之间生成随机整数,例如x = 4并y = 8输出4,5,6,7,8中的任何一个？

Answer 1

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()返回Number0(包括)和1(不包括)之间的值.所以我们有这样的间隔:

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

现在,我们想要一个介于min(包含)和max(独家)之间的数字:

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

我们可以使用它Math.random来获取[min,max]区间内的通讯记录.但是,首先我们应该通过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结果.

Answer 2

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

Answer 3

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

Answer 4

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之间的随机双精度数,如果我们将它乘以1再加上top和之间的差值bottom,我们将在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

注意:如果你传入一个非整数值或更大的数字,你会得到不良行为,但除非有人要求它,我不会深入研究参数检查代码,因为它远离原始问题的意图.

Answer 5

所有这些解决方案都使用了太多的火力，您只需要调用一个函数：Math.random();

Math.random() * max | 0;

这将返回一个介于 0（包含）和最大值（非包含）之间的随机整数：

Answer 6

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

如果您使用的是Underscore.js,则可以选择使用

_.random(min, max)

Answer 7

返回1到10之间的随机数:

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

返回1到100之间的随机数:

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

Answer 8

如果您需要介于0和最大之间的变量,您可以使用:

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

Answer 9

其他答案不占的完全合理的参数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

Answer 10

加密强

要在 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))

Answer 11

这是javascript中随机类的MS DotNet实现 -

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

Answer 12

使用此功能获取给定范围之间的随机数

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

Answer 13

我想用一个例子来解释：

在 JavaScript 中生成 5 到 25 范围内的随机整数的函数

总体概述：

(i) 首先将其转换为范围 - 从 0 开始。

(ii) 然后将其转换为您想要的范围（这样就很容易完成）。

所以基本上，如果你想生成 5 到 25 之间的随机整数，那么：

第一步：将其转换为范围 - 从 0 开始

从“最大”和“最小”中减去“下/最小数字”。IE

(5-5) - (25-5)

所以范围将是：

0-20...对吧？

第二步

现在，如果您希望两个数字都包含在范围内 - 即“0 和 20”，则等式将是：

数学方程：Math.floor((Math.random() * 21))

一般方程：Math.floor((Math.random() * (max-min +1)))

现在，如果我们将减去的/最小数字（即 5）添加到范围中 - 那么我们可以自动获得从 0 到 20 => 5 到 25 的范围

第三步

现在添加您在方程中减去的差值（即 5），并将“Math.floor”添加到整个方程中：

数学方程：Math.floor((Math.random() * 21) + 5)

一般方程：Math.floor((Math.random() * (max-min +1)) + min)

所以最终函数将是：

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

Answer 14

这是一个生成最小值和最大值（包括两者）之间的随机数的函数。

const randomInt = (max, min) => Math.round(Math.random() * (max - min)) + min;

Answer 15

在使用计算机程序生成随机数之后,如果所选数字是初始数字的一部分或全部,则仍将其视为随机数.但如果它被改变了,那么数学家就不会接受它作为一个随机数,他们可以称之为有偏差的数字.但是如果你正在为一个简单的任务开发一个程序,那么这不是一个需要考虑的案例.但是,如果您正在开发一个程序来为有价值的东西(如彩票计划或赌博游戏)生成随机数,那么如果您不考虑上述情况,您的计划将被管理层拒绝.

所以对于那些人,这是我的建议:

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

注意:在方法一中,首先我创建了一个包含所需数字的数组,然后将它们随机地放入另一个数组中.在方法二中,随机生成数字并检查它们是否在您需要的范围内.然后把它放到一个数组中.在这里,我生成了两个随机数,并使用它们的总和,通过最小化获得有用数字的失败率来最大化程序的速度.但是,添加生成的数字也会带来一些双重性.所以我建议我的第一种方法在特定范围内生成随机数.

在这两种方法中,您的控制台都会显示结果.(在Chrome中按f12打开控制台)

Answer 16

对于具有范围的随机整数,请尝试:

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

Answer 17

要获得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,基本上可以防止最大值被舍入.

希望有所帮助.

Answer 18

使用以下代码,您可以在给定范围内生成随机数组,而无需重复.

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

Answer 19

我知道这个问题已经回答了,但我的回答可以帮助别人.

我在W3Schools上找到了这个简单的方法:

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

希望这会对某人有所帮助.

Answer 20

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>

Answer 21

最低和最高之间的随机整数:

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

不是最优雅的解决方案..但快速的东西.

Answer 22

这是我用来生成随机数的方法.

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

我们执行high++是因为Math.random()生成0,(包括)和1之间的随机数(不包括)被排除的那个,意味着我们必须在执行任何数学之前将高位增加1.然后我们从高中减去低,给我们产生最高数量 - 低,然后+低,使高恢复正常,并使最低数量至少低.然后我们返回结果数字

random(7,3) 可以回来 3,4,5,6, or 7

Answer 23

下面是一个 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;
    }

Answer 24

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 位整数，因为这是 JavaScript 标准number类型可以表示的最大常见整数大小。（BigInt如果您需要更大的范围，可以修改为使用s。）无论选择的范围如何，被拒绝的生成值的比例将始终小于 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]