小开

最佳答案

/*** 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...    ...      max-1... max....   (max+1 is excluded from interval)└───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘   ← Math.floor()min     min+1               max-1    max

您不能在该等式中使用ceil()和-1，因为max现在滚动的机会略小，但您也可以滚动（不需要的）min-1结果。

小开

用途：

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)的范围内，所以我们可以向下舍入并得到一个范围在0到top-bottom的整数：

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

前面示例中的代码为我们提供了一个范围为0和top-bottom的整数，因此我们现在需要做的就是将bottom添加到该结果中，以获得范围为bottom和top的整数。： D

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

小开

function getRandomInt(lower, upper){//to create an even sample distributionreturn 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)));}

要测试此函数及其变体，请将以下超文本标记语言/JavaScript保存到文件中并用浏览器打开。代码将生成一个图，显示一百万个函数调用的分布。代码还将记录边缘情况，因此如果函数产生的值大于max或小于min，you.will.know.about.it.

<html><head><script type="text/javascript">function getRandomInt(lower, upper){//to create an even sample distributionreturn 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 distributionvar 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>

小开

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}

如果您使用的是Underscore.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]那么n的地板100的地板就是您的答案，依此类推。

现在让我们进入你的角色：

您要求的数字在特定范围内。（在这种情况下，您在该范围内有偏差。通过滚动骰子从[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的完全合理的参数。相反，您应该使用ceil或floor的round而是：

function randomNumber(minimum, maximum){return Math.round( Math.random() * (maximum - minimum) + minimum);}
console.log(randomNumber(0,1));  # 0 1 1 0 1 0console.log(randomNumber(5,6));  # 5 6 6 5 5 6console.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（包括）和范围之间的数字。

例如，以random(2,5)为例。我们将随机数0≤x<1乘以范围（5-2=3），因此我们现在有一个数字x，其中0≤x<3。

为了强制函数将max和min都视为包含，我们在范围计算中添加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之间的整数。

小开

Math.random（）

返回一个介于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 -> 10Math.floor(Math.random() * 11);
// 1 -> 10Math.floor(Math.random() * 10) + 1;
// 5 -> 20Math.floor(Math.random() * 16) + 5;
// -10 -> (-2)Math.floor(Math.random() * 9) - 10;

**总是很高兴被提醒（Mozilla）：

Math.random（）不提供加密安全的随机不要将它们用于任何与安全有关的事情。使用网络而不是加密API，更准确地说window.crypto.get随机值（）方法。

小开

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

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

小开

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

小开

用途：

<!DOCTYPE html><html><head><meta charset="utf-8" /></head>
<body><script>/*Assuming that window.crypto.getRandomValuesis available, the real range would be from0 to 1,998 instead of 0 to 2,000.
See the JavaScript documentationfor 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。这段代码非常短。

小开

我在W3学校上找到了这个简单的方法：

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

小开

这是JavaScript中随机类的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;}());

用途：

var r = new Random();var nextInt = r.Next(1, 100); // Returns an integer between rangevar 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;}

小开

如果你需要一个介于0和max之间的变量，你可以使用：

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

小开

一个名为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标准number类型可以表示的最大的公共整数大小（如果需要更大的范围，可以修改为使用BigInt）。不管选择什么范围，被拒绝的生成值的分数总是小于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));          // -2console.log(randomInteger(0, 0));           // 0console.log(randomInteger(0, 0xFFFFFFFF));  // 944450079console.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]

小开

我做了这个函数，它考虑了像min、max、排除（要排除的整数列表）和种子（如果你想要一个种子随机生成器）这样的选项。

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.minlet 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 = nbreak}}}
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;}

小开

随机（最小，最大）生成一个介于min（包括）和max（不包括）之间的随机数

Math.floor将一个数字向下舍入到最近的整数

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

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

generateRandomInteger(4, 9)

小开

非常强大

要在[x， y]范围内获取密码学强随机整数，请尝试：

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

小开

Ionu G. Stan写了一个很好的答案，但它对我来说有点太复杂了。所以，我在Math.floor（Math.random () * (max-min+1））+min）中找到了Jason Anello对相同概念的更简单的解释。

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

通过切断顶部或末端来缩短（某物）。

小开

我生成0到n之间随机数的方法，其中n<=10（n排除）：

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

小开

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

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

小开

接受答案的问题

值得注意的是，公认的答案不能正确处理分钟大于最大值的情况。这是一个例子：

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

此外，如果你不熟悉这个小算法，阅读起来有点冗长和不清楚。

为什么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>

它还处理负数、零以及你期望的所有其他内容。如果你需要做浮点数或使用其他变量类型，也有一些选项，但我不会在这里谈论它们。它们在网站上，所以如果需要，你可以在那里深入研究。最后一个原因很明显。从风格上讲，它更清晰，更容易阅读。

太长别读了给我答案…

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

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

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

小开

// Examplefunction 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 functionvar 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”中减去“低/最小数字”。即

（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)}

小开

这是一个在min和max之间生成随机数的函数，两者都包括在内。

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

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