在特定范围内的JavaScript中生成随机整数？
我怎样才能在Javascript中的两个指定的variables之间生成一个随机的整数，例如x = 4和y = 8会输出4,5,6,7,8中的任意一个？
Mozilla开发者networking页面上有一些例子：
/** * 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) * Using Math.round() will give you a non-uniform distribution! */ function getRandomInt(min, 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]间隔中的logging。 但是，首先我们应该从第二个时间间隔减去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)
所以，为了findx ，我们会这样做：
x = Math.random() * (max - min);
不要忘记添加min ，以便我们在[min，max]间隔中获得一个数字：
x = Math.random() * (max - min) + min;
这是MDN的第一个function。 第二个，返回一个整数之间的min和max ，包括两个端点。
现在为了获得整数，你可以使用round ， ceil或floor 。
您可以使用Math.round(Math.random() * (max - min)) + min ，但是这会给出非均匀分布。 min和max只有大概一半的机会滚动：
min...min+0.5...min+1...min+1.5 ... max-0.5....max └───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘ ← Math.round() min min+1 max
max排除的时间间隔，它有一个更小的机会滚动min 。
使用Math.floor(Math.random() * (max - min +1)) + min可以得到完美均匀的分布。
min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval) | | | | | | └───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘ ← Math.floor() min min+1 max-1 max
你不能在这个等式中使用ceil()和-1 ，因为max现在有一个稍微小一点的机会，但是你也可以滚动（不需要的） min-1结果。
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
的Math.random（）
从Mozilla开发者networking文档：
// Returns a random integer between min and max function getRandomInt(min, max) { return 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. }
分解：
我们正在返回一个函数（从函数式编程中借用），在调用时，会返回值bottom和top之间的一个随机整数。 我们说“包容性”，因为我们希望在可以返回的数字范围内包括底部和顶部。 这样， getRandomizer( 1, 6 )将返回1,2,3,4,5或6。
（底部是数字，顶部是数字）
Math.random() * ( 1 + top - bottom )
Math.random()返回一个0到1之间的随机双Math.random()值，如果我们将它乘以1加上top和bottom的差值，我们将在0到1+ba之间得到一个双1+ba 。
Math.floor( Math.random() * ( 1 + top - bottom ) )
Math.floor将数字四舍五入到最接近的整数。 所以我们现在有0 top-bottom所有整数。 1看起来令人困惑，但它需要在那里，因为我们总是四舍五入，所以最高的号码将永远不会实现，没有它。 我们生成的随机十进制数需要在0到(1+top-bottom)的范围内，所以我们可以向下取整，得到0到上下的整数
Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom
前面示例中的代码给了我们一个范围为0和top-bottom的整数，所以我们现在要做的就是在该结果的bottom添加bottom ，以获得范围bottom和top的整数。 ：d
注意：如果你首先传入一个非整数值或者更大的数字，你会得到不希望的行为，但除非有人要求，否则我不会深入研究参数检查代码，因为它与原始问题的意图相去甚远。
function randomRange(min, max) { return ~~(Math.random() * (max - min + 1)) + min }
如果您正在使用Underscore.js，您可以使用另一种方法
_.random(min, max)
返回1到10之间的随机数字：
Math.floor((Math.random()*10) + 1);
返回1到100之间的随机数字：
Math.floor((Math.random()*100) + 1)
其他答案没有考虑0和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
在使用计算机程序产生一个随机数之后，如果所select的数字是最初的那个数字的一部分或全部数字，它仍然被认为是一个随机数。 但是，如果它被改变了，那么math家就不会把它作为一个随机数来接受，他们可以把它称为一个有偏见的数字。 但是如果你正在开发一个简单任务的程序，这不是一个需要考虑的问题。 但是，如果你正在开发一个程序，为彩票程序或赌博游戏等有价值的东西生成一个随机数，那么如果你不考虑上述情况，你的程序将被pipe理层拒绝。
所以对于那些人来说，这里是我的build议：
用Math.random()生成一个随机数（比如说n ）
Now for [0,10) ==> n*10 (ie one digit) and for[10,100) ==> n*100 (ie 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. (ie get floor) - using Math.floor(), this can be done.
如果你知道如何读随机数字表来select一个随机数，你知道上面的过程（乘以1，10，100等等）并不违反我刚才提到的那个（因为它只改变了小数点后的位置。）
研究下面的例子，并将其发展到您的需求。
如果你需要样本[0,9]，那么n * 10的楼层是你的答案，如果需要[0,99]，那么n * 100的楼层就是你的答案，依此类推。
现在让我们进入你的angular色：
你已经询问了特定范围内的数字。 （在这种情况下，你在这个范围内是有偏差的 – 通过掷出一个骰子从[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);
注意：在方法一中，首先我创build了一个数组，其中包含您需要的数字，然后随机将它们放入另一个数组中。 在方法二中，随机生成数字，并检查那些在你需要的范围内。 然后把它放到一个数组中。 在这里，我生成了两个随机数，并使用它们的总和来最大化程序的速度，通过最小化获得有用数字的故障率。 但是添加生成的数字也会带来一些偏差。 所以我会build议我的第一个方法在特定范围内生成随机数。
在这两种方法中，控制台都会显示结果（在Chrome中按f12打开控制台）
对于具有范围的随机整数，请尝试：
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;
一般来说，使用variables来做这件事的代码是：
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. ie 4 // max(inclusive) : maximun value of a range. it must be any positive integer. ie 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; }
这里是在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
随机整数在最低和最高之间：
function randomRange(l,h){ var range = (hl); var random = Math.floor(Math.random()*range); if (random === 0){random+=1;} return l+random; }
不是最优雅的解决scheme..但一些快速。
<!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创build一个数组，填充数字最多3个数字，最多999个。这个代码很短。
这是我用来产生随机数字。
function random(high,low) { high++; return Math.floor((Math.random())*(high-low))+low; }
由于Math.random()生成一个0（包含）和1（不包含）之间的随机数，所以我们执行high++ ，这意味着我们必须在执行任何math运算之前将高位加1。 然后我们从高减低，给我们最高的数字产生 – 低，然后+低，使高回到正常，并使最低的数字至less低。 然后我们返回结果数字
random(7,3)可能会返回3,4,5,6, or 7
这是我在一个范围内的一个随机数，因为我想得到一个基数范围内的随机数指数。 例如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);
我知道这个问题已经得到解答，但我的答案可以帮助某人。
我在W3School上发现了这个简单的方法：
Math.floor((Math.random() * max) + min);
希望这将有助于某人。
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))); }
为了testing这个function，以及这个function的变化，把下面的HTML / JavaScript保存到一个文件中并用浏览器打开。 该代码将生成一个显示一百万个函数调用的分布图 。 该代码还将logging边缘情况，所以如果该函数产生的值大于最大值或小于最小值，则为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"> [' + (i + min - 1) + ']: '+array[i]+'</span> '); } document.write('<hr/>'); </script> </head> <body> </body> </html>
这可以处理生成高达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
如果你需要0到max之间的variables，你可以使用：
Math.floor(Math.random() * max);
嘿，我已经创build了一个JavaScript函数Math.random（），我们可以生成随机数 指定的长度 。 不使用任何INBUILT函数。
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; }
