如何在JavaScript中的两个指定变量之间生成随机整数，例如x=4和y=8将输出4、5、6、7、8中的任意一个？
Mozilla开发者网络页面上有一些示例：
/**
* 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（不含）之间的数字。所以我们有一个这样的间隔：
[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加回来，这样我们就可以得到[分钟，最大值]间隔内的数字：
x = Math.random() * (max - min) + min;
这是MDN的第一个函数。第二个，返回一个介于min和max之间的整数，两者都包含在内。
现在，对于整数，可以使用round、ceil或floor。
您可以使用Math.round（Math.random（）*（max-min））+min，但这给出了一个非偶数分布。最小值和最大值都只有大约一半的掷骰机会：
min...min+0.5...min+1...min+1.5 ... max-0.5....max
└───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘ ← Math.round()
min min+1 max
如果将最大值排除在区间之外，那么它比最小值滚动的机会更小。
使用Math.floor（Math.random（）*（max-min+1））+min，您可以获得完全均匀的分布。
min... min+1... ... max-1... max.... (max+1 is excluded from interval)
└───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘ ← Math.floor()
min min+1 max-1 max
你不能在这个等式中使用ceil（）和-1，因为max现在的掷骰机会稍微少了一些，但你也可以掷（不需要的）min-1的结果。
Use:
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之间的随机整数，包括bottom。我们说“包含”是因为我们希望将底部和顶部都包含在可返回的数字范围内。这样，getRandomizer（1，6）将返回1、2、3、4、5或6。
（“底部”是较低的数字，“顶部”是较大的数字）
Math.random() * ( 1 + top - bottom )
Math.random（）返回一个介于0和1之间的随机双精度，如果我们将其乘以1加上顶部和底部之间的差值，我们将得到一个介于介于0和1+b-a之间的双精度。
Math.floor( Math.random() * ( 1 + top - bottom ) )
Math.floor将数字向下舍入到最接近的整数。所以我们现在有了0和上下之间的所有整数。1看起来很令人困惑，但它需要存在，因为我们总是向下舍入，因此没有它就永远无法到达顶部数字。我们生成的随机小数需要在0到（1+上下）的范围内，这样我们就可以向下舍入，得到0到上下的整数：
Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom
上一个示例中的代码为我们提供了一个范围为0和上下的整数，因此我们现在需要做的就是将底部添加到该结果中，以获得范围为底部和顶部（含）的整数D
注意：如果你先传入一个非整数值或更大的数字，你会得到不希望的行为，但除非有人要求，否则我不会深入研究参数检查代码，因为它与原始问题的意图相去甚远。
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"> [' + (i + min - 1) + ']: '+array[i]+'</span> ');
}
document.write('<hr/>');
</script>
</head>
<body>
</body>
</html>
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
对于具有范围的随机整数，请尝试：
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;
}
function randomRange(min, max) {
return ~~(Math.random() * (max - min + 1)) + min
}
如果您使用Undercore.js，也可以使用
_.random(min, max)
使用计算机程序生成随机数后，如果选取的数字是初始数字的一部分或全部，则仍将其视为随机数。但如果它被改变了，数学家就不接受它是一个随机数，他们可以称它为一个有偏数。
但是，如果您正在为一项简单的任务开发一个程序，则不需要考虑这种情况。但是，如果你正在开发一个程序，为有价值的东西（如彩票程序或赌博游戏）生成随机数，那么如果你不考虑上述情况，你的程序将被管理层拒绝。
所以对于这类人，我的建议是：
使用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 square bracket indicates that the boundary is inclusive and a round bracket indicates the boundary is exclusive.
然后删除小数点后的其余部分。（即，获得发言权）-使用Math.floor（）。这可以完成。
如果你知道如何读取随机数表来选择一个随机数，那么你知道上面的过程（乘以1、10、100等）不会违反我在开头提到的过程（因为它只改变小数点的位置）。
研究以下示例，并根据您的需要进行开发。
如果你需要一个样本[0,9]，那么n10的下限是你的答案，如果你需要[0,99]，那么n100的下限就是你的答案等等。
现在让我们进入您的角色：
您已要求提供特定范围内的数字。（在这种情况下，你在这个范围内是有偏差的。通过掷骰子从[1,6]中取一个数字，那么你就有偏差到[1,6]，但当且仅当骰子无偏差时，它仍然是一个随机数。）
所以考虑一下你的范围==>[78，247]范围内的元素数=247-78+1=170；（因为两个边界都包含在内）。
/* Method 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打开控制台）。
要获得一个介于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的原因是，仅使用最小值可以获得比最大值多1的整数。通过从最小值中减去0.5，基本上防止了最大值被舍入。
最低和最高之间的随机整数：
function randomRange(low, high) {
var range = (high-low);
var random = Math.floor(Math.random()*range);
if (random === 0) {
random += 1;
}
return low + random;
}
这不是最优雅的解决方案，而是快速的解决方案。
返回1到10之间的随机数：
Math.floor((Math.random()*10) + 1);
返回1到100之间的随机数：
Math.floor((Math.random()*100) + 1)
其他答案没有考虑到0和1这两个完全合理的参数。相反，您应该使用圆形而不是天花板或地板：
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
这是我用来生成随机数的方法。
function random(min,max) {
return Math.floor((Math.random())*(max-min+1))+min;
}
Math.random（）返回一个介于0（含）和1（不含）之间的数字。我们将这个数字乘以范围（max-min）。这将导致一个介于0（含）和范围之间的数字。
例如，随机（2,5）。我们将随机数0≤x<1乘以范围（5-2=3），因此我们现在有一个数x，其中0≤x<3。
为了强制函数将最大值和最小值都视为包含值，我们在范围计算中添加1：Math.random（）*（max-min+1）。现在，我们将随机数乘以（5-2+1=4），得到一个数字x，即0≤x<4。如果我们对这个计算进行下限，我们得到一个整数：0≤x≤3，每个结果的可能性相等（1/4）。
最后，我们需要将其转换为请求值之间的整数。由于我们已经有一个介于0和（max-min）之间的整数，我们可以简单地通过添加最小值将值映射到正确的范围。在我们的示例中，我们将0到3之间的整数加2，得到2到5之间的整数。
数学.随机（）
返回介于min（包含）和max（包含）之间的整数随机数：
function randomInteger(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
或介于min（包含）和max（不包含）之间的任意随机数：
function randomNumber(min, max) {
return Math.random() * (max - min) + 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;
**总是很高兴被提醒（Mozilla）：
Math.random（）不提供加密安全的随机数字。不要将它们用于与安全相关的任何事情。使用Web加密API，更准确地说window.crypto.getRandomValues（）方法。
使用以下代码，您可以在给定范围内生成一个随机数数组，而无需重复。
function genRandomNumber(how_many_numbers, min, max) {
// Parameters
//
// how_many_numbers: 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): Maximum 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_numbers; 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;
}
这是我对一个范围内的随机数的看法，就像我想得到一个基数到指数范围内的一个随机数。例如，基数=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);
Use:
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
</head>
<body>
<script>
/*
Assuming that window.crypto.getRandomValues
is available, the real range would be from
0 to 1,998 instead of 0 to 2,000.
See the JavaScript documentation
for an 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创建一个最多三位数的数组，最大值为999。这段代码很短。
下面是JavaScript中Random类的Microsoft.NET实现-
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;
}());
Use:
var r = new Random();
var nextInt = r.Next(1, 100); // Returns an integer between range
var nextDbl = r.NextDouble(); // Returns a random decimal
下面是一个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;
}
一个名为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;
};
使用此函数获取给定范围内的随机数：
function rnd(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.
下面的代码使用了类似的逻辑，但生成了一个32位整数，因为这是JavaScript的标准数字类型可以表示的最大公共整数大小。（如果需要更大的范围，可以将其修改为使用BigInts。）无论选择的范围如何，生成的被拒绝值的比例始终小于0.5，因此预期的拒绝数始终小于1.0，通常接近0.0；你不必担心它会永远循环。
常量随机整数=（最小值，最大值）=>{常量范围=最大值-最小值；常量maxGeneratedValue=0xFFFFFFFF；const possibleResultValues=范围+1；const possibleGeneratedValues=最大生成值+1；常量余数=possibleGeneratedValues%possibleResultValues；const maxUnbiased=maxGeneratedValue-余数；if（！Number.isInteger（min）||！Number.isInteger（最大值）||max>Number.max_SAFE_INTEGER||min<Number.min_SAFE_INDEGER）{抛出新错误（“参数必须是安全整数。”）；}否则如果（范围>maxGeneratedValue）{抛出新错误（`范围为$｛Range｝（从$｛min｝到$｛max｝）>$｛maxGeneratedValue｝。`）；}否则，如果（最大值<最小值）{抛出新错误（`max（${max}）必须>=min（${min}）。`）；}否则如果（min==max）{返回最小值；} let生成；做{generated=crypto.getRandomValues（新Uint32Array（1））[0]；}而（生成>maxUnbiased）；return min+（生成的%possibleResultValues）；};console.log（randomInteger（-8，8））；//-2.console.log（randomInteger（0，0））；//0console.log（随机整数（0，0xFFFFFFFF））；//944450079console.log（随机整数（-1，0xFFFFFFFF））；//错误：4294967296覆盖-1到4294967295的范围>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]
主旨：https://gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e
您可以使用此代码段，
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;
}
random（min，max）生成介于min（含）和max（不含）之间的随机数Math.floor将数字向下舍入到最接近的整数函数generateRandomInteger（最小，最大）｛return数学下限（随机（最小值，最大值））}
因此，要生成一个介于4和8之间的随机整数，请使用以下参数调用上述函数：
generateRandomInteger(4, 9)
加密功能强
要获取[x，y]范围内的加密强随机整数，请尝试：
让cs=（x，y）=>x+（y-x+1）*crypto.getRandomValues（新Uint32Array（1））[0]/2**32|0控制台日志（cs（4，8））
伊奥努·G·斯坦写了一个很棒的答案，但对我来说有点太复杂了。因此，我在Math.floor（Math.random（）*（max-min+1））+min）中找到了对相同概念的更简单的解释。
注意：在阅读Jason的解释之前，你应该知道的唯一重要的事情是“truncate”的定义。他在描述Math.floor（）时使用了这个术语。牛津词典将“truncate”定义为：
通过切掉顶端或末端来缩短（某物）。
接受答案的问题
值得注意的是，接受的答案不能正确处理min大于max的情况。下面是一个例子：
min=数学ceil（2）；max=数学楼层（1）；对于（变量i=0；i<25；i++）{console.log（Math.floor（Math.random（）*（max-min+1））+min）；}
此外，如果你不熟悉这个小算法，阅读起来有点啰嗦和不清楚。
为什么Randojs是更好的解决方案？
Randomjs自动处理最小值大于最大值的情况（并且它是加密安全的）：
对于（var i=0；i<25；i++）console.log（rando（2，1））；<script src=“https://randojs.com/1.0.0.js“></script>
它还处理负数、零和其他所有你期望的东西。如果您需要执行浮点运算或使用其他变量类型，也有一些选项，但我不会在这里讨论它们。它们在网站上，因此如果需要，您可以深入研究。最后的原因很明显。从风格上看，它更干净，更容易阅读。
TL；医生，给我解决方案。。。
randojs.com使这一点和许多其他常见的随机性变得强大、可靠、简单/可读：
console.log（随机（20，30））；<script src=“https://randojs.com/1.0.0.js“></script>
// 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);
所有这些解决方案都使用了太多的火力。您只需要调用一个函数：Math.random（）；
Math.random() * max | 0;
这将返回一个介于0（包含）和max（非包含）之间的随机整数。
使用现代JavaScript+Lodash：
const generateRandomNumbers = (max, amount) => {
const numbers = [...Array(max).keys()];
const randomNumbers = sampleSize(numbers, amount);
return randomNumbers.sort((a, b) => a - b);
};
此外，TypeScript版本：
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);
};
当两个输入都是整数时，此实现可以正常工作。
function randomRange(myMin, myMax) {
return Math.floor(
Math.random() * (Math.ceil(myMax) - Math.floor(myMin) + 1) + myMin
);
}
我想用一个例子来解释：
函数在JavaScript中生成5到25范围内的随机整数
概述：（i） 首先将其转换为范围-从0开始。（ii）然后将其转换为所需的范围（然后将非常易于完成）。
所以基本上，如果你想生成从5到25的随机整数，那么：
第一步：将其转换为范围-从0开始
从“max”和“min”中减去“lower/minimum number”。即
(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);
}
我想，这是所有贡献中最简单的。
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。
这是我在网页上找到的东西：
function randomInt(e,t){return Math.floor(Math.random()*(t-e+1)+e)}
这里有一个函数，它生成一个介于最小值和最大值之间的随机数，两者都包含在内。
const randomInt = (max, min) => Math.round(Math.random() * (max - min)) + min;
以下是排字的解决方案
function getRandomInt(min:number, max:number):number {
return min+Math.round(Math.random() * (max-min));
}
for(let i:number=0; i<100; i++){
console.log(`${i+1} >> ${getRandomInt(1,6)}`)
}
推荐文章
- 什么时候JavaScript是同步的?
- 如何在Typescript中解析JSON字符串
- Javascript reduce()在对象
- 在angularJS中& vs @和=的区别是什么
- 错误"Uncaught SyntaxError:意外的标记与JSON.parse"
- JavaScript中的querySelector和querySelectorAll vs getElementsByClassName和getElementById
- 给一个数字加上st, nd, rd和th(序数)后缀
- 如何以编程方式触发引导模式?
- setTimeout带引号和不带括号的区别
- 在JS的Chrome CPU配置文件中，'self'和'total'之间的差异
- 用javascript检查输入字符串中是否包含数字
- 如何使用JavaScript分割逗号分隔字符串?
- 在Javascript中~~(“双波浪号”)做什么?
- 谷歌chrome扩展::console.log()从后台页面?
- 未捕获的SyntaxError:
