有没有办法在JavaScript中生成指定范围内的随机数（例如1到6：1,2,3,4,5或6）？
答案 0 :(得分：1908)
function randomIntFromInterval(min,max) // min and max included
{
return Math.floor(Math.random()*(max-min+1)+min);
}
它所做的“额外”是它允许以1开头的随机间隔。 因此，您可以获得10到15之间的随机数。灵活性。
答案 1 :(得分：1856)
如果你想得到1到6之间，你会计算：
Math.floor(Math.random() * 6) + 1
其中：
答案 2 :(得分：236)
来自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;
答案 3 :(得分：82)
其他解决方案：
(Math.random() * 6 | 0) + 1 ~~(Math.random() * 6) + 1 答案 4 :(得分：43)
<强> TL; DR
function generateRandomInteger(min, max) {
return Math.floor(min + Math.random()*(max + 1 - min))
}
获取随机数
generateRandomInteger(-20, 20);
下面的说明
我们需要获得一个随机整数，比如说 X 在最小值和最大值之间
右？
即 min＆lt; = X＆lt; = max
如果我们从等式中减去min，这相当于
0＆lt; =（X - min）＆lt; =（max - min）
现在，让我们将其与随机数 r 相乘
0＆lt; =（X - min）* r＆lt; =（max - min）* r
现在，让我们将 min 添加回等式
min＆lt; = min +（X - min）* r＆lt; = min +（max - min）* r
现在，让我们选择一个导致 r 的函数，使其满足我们的等式范围[min，max]。只有在 0＆lt; = r＆lt; = 1
时才可以这样做行。现在， r 的范围，即[0,1]与Math.random（）函数结果非常相似。不是吗？
Math.random（）函数返回一个浮点伪随机函数 数字在[0,1]范围内;也就是说，从0（含）到最高但不是 包括1（独家）
例如，
min + 0 *（max - min）= min
min + 1 *（max - min）= max
min + r *（max - min）= X ，其中 X 的范围分钟＆lt; = X ＆lt;的最大
以上结果 X 是随机数字。但是由于Math.random（），我们的左边界是包容性的，右边界是独占的。要包含我们的右边界，我们将右边界增加1并将结果置于最低点。
function generateRandomInteger(min, max) {
return Math.floor(min + Math.random()*(max + 1 - min))
}
generateRandomInteger(-20, 20);
答案 5 :(得分：20)
或者，在Underscore
中_.random(min, max)
答案 6 :(得分：19)
var x = 6; // can be any number
var rand = Math.floor(Math.random()*x) + 1;
答案 7 :(得分：19)
jsfiddle：https://jsfiddle.net/cyGwf/477/
随机整数：要获得min和max之间的随机整数，请使用以下代码
function getRandomInteger(min, max) {
min = Math.ceil(min);
max = Math.floor(max);
return Math.floor(Math.random() * (max - min)) + min;
}
随机浮点数：要获得min和max之间的随机浮点数，请使用以下代码
function getRandomFloat(min, max) {
return Math.random() * (max - min) + min;
}
参考：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random
答案 8 :(得分：13)
数学不是我的强项，但我一直致力于一个项目，我需要在正面和负面之间产生大量随机数。
function randomBetween(min, max) {
if (min < 0) {
return min + Math.random() * (Math.abs(min)+max);
}else {
return min + Math.random() * max;
}
}
E.g
randomBetween(-10,15)//or..
randomBetween(10,20)//or...
randomBetween(-200,-100)
当然，您还可以添加一些验证，以确保您不会使用除数字之外的任何其他内容。还要确保min始终小于或等于max。
答案 9 :(得分：11)
基于 Francis 代码的 ES6 / Arrow 函数版本（即最佳答案）：
const randomIntFromInterval = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);
答案 10 :(得分：8)
我编写了更灵活的函数，它可以为您提供随机数，但不仅仅是整数。
function rand(min,max,interval)
{
if (typeof(interval)==='undefined') interval = 1;
var r = Math.floor(Math.random()*(max-min+interval)/interval);
return r*interval+min;
}
var a = rand(0,10); //can be 0, 1, 2 (...) 9, 10
var b = rand(4,6,0.1); //can be 4.0, 4.1, 4.2 (...) 5.9, 6.0
修正版。
答案 11 :(得分：6)
实施例
返回1到10之间的随机数：
Math.floor((Math.random() * 10) + 1);
结果可能是：
3
尝试自己：here
-
或使用lodash / unexcore：
_.random(min, max)
答案 12 :(得分：6)
Math.floor(Math.random() * 6) + 1。任务：生成 1 到 6 之间的随机数。
Math.random() 返回 0 到 1 之间的浮点数（例如 0.344717274374 或 0.99341293123），我们将其用作百分比，因此 Math.floor(Math.random() * 6) + 1 返回 6（最大：5，最小：0）并添加 1。 作者很幸运，下限为 1。，因为百分比下限将“最大”返回小于 6 乘以 1 的 5，而下限 1 将加上 1。
下界大于1时会出现问题。例如， 任务：在 2 到 6 之间随机生成。
（遵循作者的逻辑）
Math.floor(Math.random() * 6) + 2，很明显，如果我们在这里得到 5 -> Math.random() * 6 然后加上 2，结果将是 7，超出了所需的边界 6。
另一个例子， 任务：在 10 到 12 之间随机生成。
Math.floor(Math.random() * 12) + 10，（抱歉重复）很明显，我们得到了数字 “12” 的 0%-99%，这将远远超出所需的 12 边界。所以，正确的逻辑是取下限和上限的差加1，然后才把它取下（到减去 1，因为 Math.random() 返回 0 - 0.99，所以无法获得完整的上限，这就是为什么我们将上限加 1 以获得最大（上限 + 1）的 99%，然后我们将其取底得到去除多余）。一旦我们得到了 (difference + 1) 的下限百分比，我们就可以添加下边界以获得 2 个数字之间所需的随机数。
其逻辑公式为：Math.floor(Math.random() * ((up_boundary - low_boundary) + 1)) + 10。
Ps：即使是评分最高的答案下的评论也是不正确的，因为人们忘记在差异中添加1，这意味着他们永远不会获得上限< em>（是的，如果他们根本不想得到它可能是一种情况，但要求是包含上限）。
答案 13 :(得分：5)
尽管有很多答案和几乎相同的结果。我想补充一下我的答案并解释它的工作原理。因为理解它的工作而不是复制粘贴一行代码很重要。生成随机数只不过是简单的数学。
CODE：
function getR(lower, upper) {
var percent = (Math.random() * 100);
// this will return number between 0-99 because Math.random returns decimal number from 0-0.9929292 something like that
//now you have a percentage, use it find out the number between your INTERVAL :upper-lower
var num = ((percent * (upper - lower) / 100));
//num will now have a number that falls in your INTERVAL simple maths
num += lower;
//add lower to make it fall in your INTERVAL
//but num is still in decimal
//use Math.floor>downward to its nearest integer you won't get upper value ever
//use Math.ceil>upward to its nearest integer upper value is possible
//Math.round>to its nearest integer 2.4>2 2.5>3 both lower and upper value possible
console.log(Math.floor(num), Math.ceil(num), Math.round(num));
}
答案 14 :(得分：5)
这支持负整数：
Math.floor(Math.random() * (max - min + 1)) + min;
答案 15 :(得分：4)
我正在搜索用TypeScript编写的随机数生成器，我在阅读了所有答案之后写了这个，希望它适用于TypeScript编码器。
Rand(min: number, max: number): number {
return (Math.random() * (max - min + 1) | 0) + min;
}
答案 16 :(得分：3)
使用随机函数，可重复使用。
function randomNum(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
randomNum(1, 6);
答案 17 :(得分：3)
基于@Francisc的答案中的float版本添加具有固定精度版本的int：
function randomFloatFromInterval (min, max, fractionDigits) {
const fractionMultiplier = Math.pow(10, fractionDigits)
return Math.round(
(Math.random() * (max - min) + min) * fractionMultiplier,
) / fractionMultiplier
}
如此：
randomFloatFromInterval(1,3,4) // => 2.2679, 1.509, 1.8863, 2.9741, ...
对于int答案
randomFloatFromInterval(1,3,0) // => 1, 2, 3
答案 18 :(得分：2)
尝试使用：
function random(min, max) {
return Math.round((Math.random() *( Math.abs(max - min))) + min);
}
console.log(random(1, 6));
答案 19 :(得分：1)
这对我有用，并产生类似Python的random.randint标准库函数的值：
function randint(min, max) {
return Math.round((Math.random() * Math.abs(max - min)) + min);
}
console.log("Random integer: " + randint(-5, 5));
答案 20 :(得分：1)
此函数可以生成一个介于（包括）最小和最大数之间的随机整数：
function randomNumber(min, max) {
if (min > max) {
let temp = max;
max = min;
min = temp;
}
if (min <= 0) {
return Math.floor(Math.random() * (max + Math.abs(min) + 1)) + min;
} else {
return Math.floor(Math.random() * max) + min;
}
}
示例：
randomNumber(-2, 3); // can be -2, -1, 0, 1, 2 and 3
randomNumber(-5, -2); // can be -5, -4, -3 and -2
randomNumber(0, 4); // can be 0, 1, 2, 3 and 4
randomNumber(4, 0); // can be 0, 1, 2, 3 and 4
答案 21 :(得分：1)
如果起始数字是 1，如您的示例 (1-6)，您可以使用 Math.ceil() 方法而不是 Math.floor()。
Math.ceil(Math.random() * 6)
代替
Math.floor(Math.random() * 6) + 1
不要忘记其他有用的数学方法。
答案 22 :(得分：0)
Crypto-strong中的随机数字[r，b]（假设：a let rand= (a,b)=> a+(b-a+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0
console.log(rand(1,6))
答案 23 :(得分：0)
基本上像骰子一样返回1-6， 返回Math.round（Math.random（）* 5 +1）;
答案 24 :(得分：0)
表示大数字。
var min_num = 900;
var max_num = 1000;
while(true){
let num_random = Math.random()* max_num;
console.log('input : '+num_random);
if(num_random >= min_num){
console.log(Math.floor(num_random));
break;
} else {
console.log(':::'+Math.floor(num_random));
}
}
答案 25 :(得分：0)
我发现了一种使用ES6默认参数执行此操作的好方法。这很漂亮，因为它允许一个参数或两个参数。在这里：
function random(n, b = 0) {
return Math.random() * (b-n) + n;
}
答案 26 :(得分：0)
这应该有效：
const getRandomNum = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min
答案 27 :(得分：0)
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)); // -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]
答案 28 :(得分：0)
一个简单的单衬：
Math.floor( Math.random() * MAX_NUMBER ) + MIN_NUMBER
例如：
Math.floor( Math.random() * 6 ) + 1
答案 29 :(得分：-1)
这大约晚了九年，但是randojs.com使这变得简单了：
rando(1, 6)
您只需要将此内容添加到html文档的开头，就可以轻松地随机执行几乎任何您想做的事情。来自数组的随机值，随机的jquery元素，对象的随机属性，甚至在需要时防止重复。
<script src="https://randojs.com/1.0.0.js"></script>
答案 30 :(得分：-5)
我发现上面的Francisc的解决方案不包括结果中的最小或最大数字，所以我改变了它：
function randomInt(min,max)
{
return Math.floor(Math.random()*(max-(min+1))+(min+1));
}