Math.random()

Question

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

Answer 1

/**
 * 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()在0（包括）和1（不包括）之间返回Number。所以我们有这样的间隔：

[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开发人员网络文档：

// 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之间的随机双精度数，如果我们将它乘以一加上top和bottom之间的差值，我们会在{{{{}}之间得到一个双精度1}}和0。

1+b-a

Math.floor( Math.random() * ( 1 + top - bottom ) )将数字向下舍入到最接近的整数。所以我们现在拥有Math.floor和0之间的所有整数。 1看起来令人困惑，但它需要在那里，因为我们总是向下舍入，所以如果没有它，那么最高的数字将永远不会实现。我们生成的随机小数需要在top-bottom到0的范围内，因此我们可以向下舍入并获得范围(1+top-bottom)到0

的整数

top-bottom

上一个示例中的代码为我们提供了Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom和0范围内的整数，因此我们现在需要做的就是将top-bottom添加到该结果中以获取整数范围bottom和bottom包含在内。：d

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

Answer 5

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

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

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

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

Answer 6

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

如果您使用 Underscore.js ，则可以使用

_.random(min, max)

Answer 7

其他答案没有考虑0和1的完全合理的参数。相反，您应该使用round或ceil的{{1}} 代替：

floor

Answer 8

如果需要0到最大值之间的变量，可以使用：

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

Answer 9

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

所以对于那些人，这是我的建议：

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

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

在这两种方法中，您的控制台都会显示结果。（在Chrome中按f12打开控制台）

Answer 10

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

Math.random() * max | 0;

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

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 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 13

要获得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 14

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

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 15

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

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

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

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

Answer 16

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

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

不是最优雅的解决方案......但速度很快。

Answer 17

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

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 18

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

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

Answer 19

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保存到文件并使用浏览器打开。代码将生成一个图形，显示一百万个函数调用的分布。代码也会记录边缘情况，所以如果函数产生的值大于最大值，或者小于min，那么you.will.know.about.it。

<html>
    <head>
        <script type="text/javascript">
        function getRandomInt(lower, upper)
        {
            //to create an even sample distribution
            return Math.floor(lower + (Math.random() * (upper - lower + 1)));

            //to produce an uneven sample distribution
            //return Math.round(lower + (Math.random() * (upper - lower)));

            //to exclude the max value from the possible values
            //return Math.floor(lower + (Math.random() * (upper - lower)));
        }

        var min = -5;
        var max = 5;

        var array = new Array();

        for(var i = 0; i <= (max - min) + 2; i++) {
          array.push(0);
        }

        for(var i = 0; i < 1000000; i++) {
            var random = getRandomInt(min, max);
            array[random - min + 1]++;
        }

        var maxSample = 0;
        for(var i = 0; i < max - min; i++) {
            maxSample = Math.max(maxSample, array[i]);
        }

        //create a bar graph to show the sample distribution
        var maxHeight = 500;
        for(var i = 0; i <= (max - min) + 2; i++) {
            var sampleHeight = (array[i]/maxSample) * maxHeight;

            document.write('<span style="display:inline-block;color:'+(sampleHeight == 0 ? 'black' : 'white')+';background-color:black;height:'+sampleHeight+'px">&nbsp;[' + (i + min - 1) + ']:&nbsp;'+array[i]+'</span>&nbsp;&nbsp;');
        }
        document.write('<hr/>');
        </script>
    </head>
    <body>

    </body>
</html>

Answer 20

    <!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.此代码非常短。

Answer 21

这是一个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 22

想用一个例子来解释：

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

<块引用>

一般概述：

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

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

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

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

从“最大值”和“最小值”中减去“较低/最小值”。即

(5-5) - (25-5)

所以范围是：

0-20 ...对吗？

b) 第二步：

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

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

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

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

c) 第三步

现在添加您在等式（即 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 23

这是我对一个范围内的随机数的看法，因为我想得到一个基数到指数范围内的随机数。例如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);

Answer 24

我想这是所有贡献中最简化的。

maxNum = 8,
minNum = 4

console.log(Math.floor(Math.random() * (maxNum - minNum) + minNum))

console.log(Math.floor(Math.random() * (8 - 4) + 4))

这会将 4 到 8 之间的随机数记录到控制台中，包括 4 和 8。

Answer 25

要获得crypto-strong随机数字以拉涅[x，y]尝试

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

console.log(rand(4,8))

Answer 26

您可以使用此代码段

isa

Answer 27

当两个输入都是整数时，此实现有效。

function randomRange(myMin, myMax) {
  return Math.floor(
    Math.random() * (Math.ceil(myMax) - Math.floor(myMin) + 1) + myMin
  );
}

Answer 28

/ * 编写一个名为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;
};

Answer 29

// Example
function ourRandomRange(ourMin, ourMax) {
    return Math.floor(Math.random() * (ourMax - ourMin + 1)) + ourMin;
}

ourRandomRange(1, 9);

// Only change code below this line.
function randomRange(myMin, myMax) {
    var a = Math.floor(Math.random() * (myMax - myMin + 1)) + myMin;
    return a; // Change this line
}

// Change these values to test your function
var myRandom = randomRange(5, 15);

Answer 30

为获得最佳性能，您可以简单地使用：

var r = (Math.random() * (maximum - minimum + 1) ) << 0

Answer 31

我生成0到n（不包括n）之间的随机数的方法：

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

Answer 32

Ionuț G. Stan给出了一个很好的答案，但这对我来说太复杂了。因此，我在Jason Anello的https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation中找到了对相同概念的更简单解释。

注意：：在阅读Jason的解释之前，您应该了解的唯一重要的事情是“截断”的定义。他在描述Math.floor()时使用了该术语。牛津词典将“截断”定义为：

通过切开顶部或末端来缩小（某些东西）。

Answer 33

random（min，max）生成一个介于min（含）和max（不含）之间的随机数

Math.floor将数字四舍五入到最接近的整数

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

因此，要生成一个介于4和8之间的随机整数，请使用以下参数调用上述函数：

generateRandomInteger (4,9)

Answer 34

我制作此函数时考虑了最小值，最大值，排除（要排除的整数列表）和种子（如果需要种子随机生成器）的选项。

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

Answer 35

reduce([1, 2, 3, 4], (array, b) => [...array, b], [])快速且适用于多种用途，但是如果您需要密码安全的值（不安全），或者需要完全均匀无偏分布的整数（在其他答案会比其他答案更经常地产生某些值。

在这种情况下，我们可以使用Math.random()来生成安全整数，并拒绝我们无法将其统一映射到目标范围内的所有生成的值。这样会比较慢，但是除非您生成非常大量的值，否则它就不重要了。

要弄清偏差分布的问题，请考虑以下情况：我们要生成一个介于1和5之间的值，但是我们有一个随机数生成器，它产生介于1和16之间的值（一个4位值）。我们希望有相同数量的生成值映射到每个输出值，但是16不能平均除以5：它剩下1的余数。因此，我们需要拒绝1个可能的生成值，并且仅当得到可以统一映射到我们目标范围内的15个较小值之一。我们的行为可能类似于此伪代码：

crypto.getRandomValues()

以下代码使用类似的逻辑，但是会生成一个32位整数，因为这是可以由JavaScript的标准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。）无论选择哪个范围，被拒绝的生成值的比例始终小于0.5，因此预期的拒绝数量将始终小于1.0，通常接近0.0；您不必担心它会永远循环。

BigInt

Answer 36

这可以处理最多20位的UNIQUE随机数

<强> JS

var generatedNumbers = [];

function generateRandomNumber(precision) { // precision --> number precision in integer 
    if (precision <= 20) {
        var randomNum = Math.round(Math.random().toFixed(precision) * Math.pow(10, precision));
        if (generatedNumbers.indexOf(randomNum) > -1) {
            if (generatedNumbers.length == Math.pow(10, precision))
                return "Generated all values with this precision";
                return generateRandomNumber(precision);
        } else {
            generatedNumbers.push(randomNum);
            return randomNum;
        }
    } else
       return "Number Precision shoould not exceed 20";
}
generateRandomNumber(1);

JsFiddle

Answer 37

使用现代 JavaScript + Lodash

const generateRandomNumbers = (max, amount) => {
  const numbers = [...Array(max).keys()];
  const randomNumbers = sampleSize(numbers, amount);

  return randomNumbers.sort((a, b) => a - b);
};

还有打字稿版本

const generateRandomNumbers = (max: number, amount: number) => {
  const numbers = [...Array(max).keys()];
  const randomNumbers: number[] = sampleSize(numbers, amount);

  return randomNumbers.sort((a: number, b: number) => a - b);
};

Answer 38

我想知道足够运行后的分布情况如何这样的随机函数。

还要检查该分布在不同的浏览器中是否大致相同。

这是要运行的代码段。可以在按下按钮之前更改数字。

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>

Answer 39

替代解决方案：-

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

Answer 40

这是我在网页上找到的内容：

function randomInt(e,t){return Math.floor(Math.random()*(t-e+1)+e)}

Answer 41

问题已被接受

值得注意的是，接受的答案不能正确处理min大于max的情况。这是一个示例：

min = Math.ceil(2);
max = Math.floor(1);
for(var i = 0; i < 25; i++) {
  console.log(Math.floor(Math.random() * (max - min + 1)) + min);
}

此外，如果您不熟悉这种小算法，可能会有点罗and和不清楚。

为什么Randojs是更好的解决方案？

Randojs自动处理min大于max的情况（并且它是加密安全的）：

for(var i = 0; i < 25; i++) console.log(rando(2, 1));

<script src="https://randojs.com/1.0.0.js"></script>

它还处理负数，零以及您期望的其他所有内容。如果您需要进行浮点运算或使用其他变量类型，那么也可以使用这些选项，但是在这里我不会谈论它们。它们位于site上，因此您可以根据需要深入研究。最终原因很明显。从风格上讲，它更干净，更易于阅读。

TL; DR。给我解决方案...

randojs.com使它和大量其他常见随机性变得健壮，可靠，就像这样简单/可读：

console.log(rando(20, 30));

<script src="https://randojs.com/1.0.0.js"></script>

Answer 42

生成五位数的随机数

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

示例

 rn(2342, 9999)

希望有帮助

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

42 个答案:

Math.random()

问题已被接受

为什么Randojs是更好的解决方案？

TL; DR。给我解决方案...