【问题标题】：Generate random number between two numbers in JavaScript在 JavaScript 中生成两个数字之间的随机数
【发布时间】：2014-10-02 07:10:17
【问题描述】：

有没有办法用 JavaScript 在指定范围中生成一个随机数？

例如：从1到6的指定范围，其中随机数可以是1、2、3、4、5或6。

【问题讨论】：

Math.floor(Math.random() * 7)
当然.. Math.floor(Math.random()*6+1)
Nabil Kadimi 也在how to generate negative random numbers 上写了一篇文章。
这里有一个有用的要点：gist.github.com/kerimdzhanov/7529623
为什么像Math.floor((Math.random()*10)+1); 这样的解决方案不能像w3schools.com/jsref/jsref_random.asp 在这里指定的那样为您工作..？

标签： javascript random

【解决方案1】：

获取 0 和 400

之间的随机整数

var rand = Math.round(Math.random() * 400);

document.write(rand);

获取 200 到 1500

之间的随机整数

const range = {min: 200, max: 1500}, 
      delta = range.max - range.min;

var rand = Math.round(range.min + Math.random() * delta);

document.write(rand);

使用函数

function randBetween(min, max){
  let delta = max - min;
  return Math.round(min + Math.random() * delta);
}

document.write(randBetween(10, 15));

// JavaScript ES6

const randBetween = (min, max) => {
  let delta = max - min;
  return Math.round(min + Math.random() * delta);
}

document.write(randBetween(10, 20));

【讨论】：

【解决方案2】：

一个简单的单行：

Math.floor( Math.random() * MAX_NUMBER ) + MIN_NUMBER

例子：

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

【讨论】：

【解决方案3】：

这支持负整数：

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

【讨论】：

【解决方案4】：

function randomIntFromInterval(min, max) { // min and max included 
  return Math.floor(Math.random() * (max - min + 1) + min)
}

const rndInt = randomIntFromInterval(1, 6)
console.log(rndInt)

它“额外”的作用是它允许不以 1 开头的随机间隔。因此，例如，您可以获得 10 到 15 之间的随机数。灵活性。

【讨论】：

这也很棒，因为如果有人不包括 to arg，from arg 会兼作最大值
你好。这是来自 MDN：Returns a floating-point, pseudo-random number in the range [0, 1) that is, from 0 (inclusive) up to but not including 1 (exclusive), which you can then scale to your desired range. (developer.mozilla.org/en-US/docs/JavaScript/Reference/…)
阅读以上评论。随机在 [0,1) 内，而不是 [0,1]。
如果较低的数字为 0，效果很好。
注意这个解只有当min和max都是整数时才是正确的，否则你可以得到区间[min, ceil(max)]的结果。 IE。你可以得到一个超出范围的结果，因为它高于最大值。

【解决方案5】：

重要

以下代码仅在最小值为 1 时才有效。它不适用于“1”以外的最小值。

如果你想得到一个介于 1（只有 1）和 6 之间的随机整数，你可以计算：

    const rndInt = Math.floor(Math.random() * 6) + 1
    console.log(rndInt)

地点：

1 是起始编号
6 是可能结果的数量（1 + 开始 (6) - 结束 (1)）

【讨论】：

虽然这可行，@Mike，但最好指出更通用的版本，因为 Francisc 在下面有它:-)。
-1。谷歌搜索后，我发现这个问题的标题是“在 Javascript 中生成两个数字之间的随机值”。如果最小值为 0，则不起作用
如果您想要两个较大数字之间的数字，例如，则不起作用。 Math.floor(Math.random() * 900) + 700
只有在最小值为 1 时才有效。如果最小值为 2 并且我们仍然使用 Math.floor(Math.random() * 6) + 2 意味着如果 Math.random() 结果为 0.99，我们的随机值将是 7
此代码不好，因为它不适用于任何数字。 @Francisc 代码是正确的。

【解决方案6】：

如果起始数字是 1，如您的示例 (1-6)，您可以使用 Math.ceil() 方法而不是 Math.floor()。

Math.ceil(Math.random() * 6)

而不是

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

我们不要忘记其他有用的数学方法。

【讨论】：

【解决方案7】：

使用随机函数，可以重复使用。

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

【讨论】：

【解决方案8】：

评分最高的解决方案在数学上与下面的 cmets 不同 -> `Math.floor(Math.random() * 6) + 1`.

任务： 生成 1 到 6 之间的随机数。

Math.random() 返回 0 和 1 之间的浮点数（例如 0.344717274374 或 0.99341293123），我们将其用作百分比，因此 Math.floor(Math.random() * 6) + 1 返回 6 的某个百分比（最大值： 5, min: 0) 并添加 1。 作者很幸运，下限是 1。，因为百分比下限将“最大”返回小于 6 的 5 乘以 1，并且下限 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 边界。

所以，正确的逻辑是取lower bound和upper bound之差加上1，然后才将其置底（到减去 1，因为Math.random() 返回 0 - 0.99，所以没有办法得到完整的上限，这就是为什么我们将 1 加到上限以获得最大 99%（上限 + 1）然后我们将其降低以摆脱过量的）。一旦我们得到 (difference + 1) 的下限百分比，我们就可以添加下边界来获得 2 个数字之间的所需随机数。

其逻辑公式为：Math.floor(Math.random() * ((up_boundary - low_boundary) + 1)) + 10。

Ps：即使是评分最高的答案下的 cmets 也不正确，因为人们忘记在 difference 上加上 1，这意味着他们永远不会得到上边界（是的，如果他们根本不想得到它可能是一种情况，但要求是包括上边界）。

【讨论】：

Math.floor(Math.random() * ((up_boundary - low_boundary) + 1)) + low_boundary

【解决方案9】：

基于 Francis 代码的 ES6 / 箭头函数版本（即最佳答案）：

const randomIntFromInterval = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);

【讨论】：

不错！提供min 和max 值非常有用。我一直在寻找这个答案。

【解决方案10】：

此函数可以生成介于（并包括）最小和最大数字之间的随机整数：

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 + 1)) + 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

【讨论】：

如果 max = 6 和 min = 0，这将永远不会滚动 6
@mesqueeb 我编辑了我的答案，因为Math.random() 永远不会是 1。
我认为你的答案在“理论”方面很好，但如果你能在你的答案中清楚地说明 max = 6 是否会“包括”6 的可能性，并且如果 min = 1 会“包括” 1 的可能性吗？这可以非常含糊地阅读，并且可能会使人们感到困惑。是“最大 6 - 包括 6”还是“最大 6 - 不包括 6”...“最小”也是如此。
我更新了我的答案以消除歧义并添加负数的可能性。
temp 未使用。

【解决方案11】：

对于大数字。

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

【讨论】：

【解决方案12】：

基本上像骰子一样返回1-6，

return Math.round(Math.random() * 5 + 1);

【讨论】：

【解决方案13】：

Math.random()

在最小值（包含）和最大值（包含）之间返回一个integer random number：

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

或any random number 在最小值（包括）和最大值（不包括）之间：

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() 不提供加密安全随机数字。不要将它们用于与安全相关的任何事情。使用网络取而代之的是 Crypto API，更准确地说是 window.crypto.getRandomValues() 方法。

【讨论】：

让我感到困惑的事情...... Math.floor(..) 确保数字是整数，其中 Math.round(..) 会给出不均匀的分布。参考：developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
我相信这个答案。任何人都可以给出一个链接或明确解释为什么这有效吗？也许是 Math.round 如何给出偏差的一个例子，为什么这意味着我们必须使用这个看起来相当复杂的公式？
@alikuli 对于[1,2] 的范围，Math.random() 有 25% 的机会会为您提供来自这些[0,0.49]、[0.5,0.99]、[1,1.49]、[1.5,1.99] 之一的数字.对这些区间进行四舍五入将导致 0、1、1、2 不是均匀分布。铺设它们会导致 0、0、1、1。
@shuji 这是，除其他外，正确答案。我只是想澄清为什么使用Math.round 而不是Math.floor 会产生不同的结果。
我找到的最准确的解决方案：function getRandomInt(min, max) { return Math.round((min - 0.5) + Math.random() * (max - min + 1)); }

【解决方案14】：

Crypto-strong [a,b] 范围内的随机整数（假设：a

let rand= (a,b)=> a+(b-a+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0

console.log( rand(1,6) );

【讨论】：

【解决方案15】：

尝试使用：

function random(min, max) {
   return Math.round((Math.random() *( Math.abs(max - min))) + min);
}
console.log(random(1, 6));

【讨论】：

【解决方案16】：

这对我有用，并产生类似于 Python 的 random.randint 标准库函数的值：


function randint(min, max) {
   return Math.round((Math.random() * Math.abs(max - min)) + min);
}

console.log("Random integer: " + randint(-5, 5));

【讨论】：

【解决方案17】：

这大约晚了九年，但randojs.com 使它成为一个简单的单行：

rando(1, 6)

您只需将其添加到您的 html 文档的头部，您就可以轻松地随心所欲地做任何您想做的事情。来自数组的随机值、随机的 jquery 元素、来自对象的随机属性，甚至在需要时防止重复。

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

【讨论】：

【解决方案18】：

其他解决方案：

(Math.random() * 6 | 0) + 1
~~(Math.random() * 6) + 1

Try online

【讨论】：

您介意解释（或引用）~~ sintaxis 吗？我以前没见过！优雅的解决方案，但难以理解。
Double Tilde ~~a 和 Bitwise OR (a | 0) 是编写 Math.floor(a) 的更快方法
a | 0 也是将字符串转换为整数的最快和最优化的方法。它仅适用于包含整数的字符串（"444" 和 "-444"），即没有浮点数/分数。对于所有失败的事情，它都会产生一个0。它是 asm.js 背后的主要优化之一。
@edi9999 编写速度更快，但执行速度也更快？
注意：如果您正在处理一些非常大的数字，则双波浪号将不起作用。试试~~(Math.random() * (50000000000000 - 0 + 1)) + 0 和Math.floor(Math.random() * (50000000000000 - 0 + 1)) + 0

【解决方案19】：

我发现了一种使用 ES6 默认参数的新方法。它非常漂亮，因为它允许一个参数或两个参数。这里是：

function random(n, b = 0) {
    return Math.random() * (b-n) + n;
}

【讨论】：

【解决方案20】：

这应该可行：

const getRandomNum = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min

【讨论】：

【解决方案21】：

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]

【讨论】：

@2xSamurai 在那里，我更新了答案以解释您为什么需要它以及它是如何工作的。那个更好吗？ :P
如果您想要加密安全和均匀分布的随机数，这一点也不为过。生成满足这些要求的随机数很困难。很好的答案，@JeremyBanks。

【解决方案22】：

在@Francisc 的回答中基于int 版本添加具有固定精度版本的float：

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

【讨论】：

【解决方案23】：

TL;DR

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

获取随机数 generateRandomInteger(-20, 20);

解释如下

我们需要得到一个随机整数，比如说 X 在 min 和 max 之间。

对吗？

即最小

如果我们从等式中减去 min，这相当于

0

现在，让我们将它与一个随机数相乘 r 这是

0

现在，让我们将 min 加回方程

min

现在，让我们选择一个函数，它会导致 r 满足我们的方程范围为 [min,max]。这只有在 0

时才有可能

好的。现在，r 的范围即 [0,1] 与 Math.random() 函数结果非常相似。不是吗？

Math.random() 函数返回一个浮点伪随机数 [0, 1) 范围内的数字；即从 0（含）到但不包括1个（独家）

例如，

案例 r = 0

min + 0 * (max-min) = min

案例 r = 1

min + 1 * (max-min) = 最大

使用 Math.random 的随机案例 0

min + r * (max-min) = X，其中 X 的范围为 min X 最大

上面的结果X是一个随机数字。然而，由于 Math.random()，我们的左边界是包容性的，而右边界是排斥性的。为了包括我们的右边界，我们将右边界增加 1 并将结果取底。

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

获取随机数

generateRandomInteger(-20, 20);

【讨论】：

【解决方案24】：

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

【讨论】：

【解决方案25】：

尽管有很多答案和几乎相同的结果。我想添加我的答案并解释它的工作原理。因为重要的是要了解它的工作原理，而不是复制粘贴一行代码。生成随机数不过是简单的数学运算。

代码：

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

【讨论】：

【解决方案26】：

例子

返回一个介于 1 到 10 之间的随机数：

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

结果可能是： 3

试试自己：here

--

或使用 lodash / undescore:

_.random(min, max)

文档： - lodash - undescore

【讨论】：

所以你需要 9 或 10 对吗？如果是： const randomNumber = Math.floor((Math.random() * 10) + 1) const NineOrTen = randomNumber % 2 === 0 ？ 9 : 10

【解决方案27】：

我写了更灵活的函数，它可以给你随机数，但不仅仅是整数。

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

固定版本。

【讨论】：

这不是一个好的解决方案，因为它不能以零作为最小值。请参阅@Lior 的回答。
当然，它使用零作为最小值。你试过了吗？没有理由它可能不起作用。它不能使用 0 作为间隔，这并不奇怪（interval = 0?...）。
我多次以零作为最小值运行此函数，但从未在输出中获得零。或者我不够幸运……
你是对的。 "+interval" 放错地方了。请现在测试一下。奇怪的事情有时 console.log 给我 0.300000004 而不是 0.3 像 3*0.1 不会完全是 0.3。

【解决方案28】：

或者，Underscore

_.random(min, max)

【讨论】：

【解决方案29】：

我正在搜索用 TypeScript 编写的随机数生成器，我在阅读了所有答案后写了这个，希望它适用于 TypeScript 编码器。

    Rand(min: number, max: number): number {
        return (Math.random() * (max - min + 1) | 0) + min;
    }

【讨论】：

【解决方案30】：

数学不是我的强项，但我一直在做一个项目，我需要在正负之间生成大量随机数。

function randomBetween(min, max) {
    if (min < 0) {
        return min + Math.random() * (Math.abs(min)+max);
    }else {
        return min + Math.random() * max;
    }
}

例如

randomBetween(-10,15)//or..
randomBetween(10,20)//or...
randomBetween(-200,-100)

当然，您还可以添加一些验证，以确保您不会对数字以外的任何内容执行此操作。还要确保 min 始终小于或等于 max。

【讨论】：

这是完全错误的。 min + Math.random() * max 会给你介于 min 和 min+max 之间的数字，这不是你想要的。 if 的第一个分支是正确的，但可以简化为 return min + Math.random() * (max - min)，无论 min 是正数还是负数，这都是正确的解决方案（请参阅其他答案）。另外，请记住，如果您不想要分数，您仍然需要对结果进行求底。

使用函数

重要

评分最高的解决方案在数学上与下面的 cmets 不同 -> Math.floor(Math.random() * 6) + 1.

（按照作者的逻辑） Math.floor(Math.random() * 12) + 10，（抱歉重复）很明显，我们得到了数字 “12” 的 0%-99%，这将远远超出所需的 12 边界。

Math.random()

案例 r = 0

案例 r = 1

使用 Math.random 的随机案例 0

获取随机数

评分最高的解决方案在数学上与下面的 cmets 不同 -> `Math.floor(Math.random() * 6) + 1`.

（按照作者的逻辑） `Math.floor(Math.random() * 12) + 10`，（抱歉重复）很明显，我们得到了数字 “12” 的 0%-99%，这将远远超出所需的 12 边界。