在JavaScript中生成特定范围内的随机整数？的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

这是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 3

对于具有范围的随机整数，请尝试：

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 4

要获得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 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;
        }

Answer 6

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

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

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

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

Answer 7

使用此函数可获得给定范围之间的随机数

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

Answer 8

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

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

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

Answer 9

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 10

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

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 11

    <!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 12

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

Answer 13

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

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

你可以这个代码片段，

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

Answer 16

这可以处理最多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 17

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

Answer 18

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类型表示的最大公共整数大小。（如果需要更大的范围，可以修改为使用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]

Answer 19

我创建了这个函数，它考虑了min，max，exclude（要排除的int列表）和种子（如果你想要一个种子随机生成器）等选项。

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 20

替代解决方案： -

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 21

我想知道经过足够的运行之后的分布将如何用于这样的随机函数。

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

所以这是一个运行的片段。按下按钮之前可以更改数字。

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 22

生成五位数的随机数

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

例

 rn(2342, 9999)

希望能帮助到你

Answer 23

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 24

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范围内的int

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

前面例子中的代码给了我们0和top-bottom范围内的整数，所以我们现在要做的就是将bottom添加到该结果中以获得bottom和top范围内的整数。：d

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

Answer 25

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

如果您使用Underscore.js可以使用替代方案

_.random(min, max)

Answer 26

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

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

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

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

Answer 27

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

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

Answer 28

其他答案没有考虑到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 29

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

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

使用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打开控制台）

在JavaScript中生成特定范围内的随机整数？的Math.random（）

问题描述投票：1730回答：29

29个回答

Math.random()

最新问题

在JavaScript中生成特定范围内的随机整数？的Math.random（）

问题描述 投票：1730回答：29

29个回答

Math.random()

最新问题

问题描述投票：1730回答：29