在 JavaScript 中生成两个数字之间的随机数

function randomIntFromInterval(min, max) { // 包括 min 和 max return Math.floor(Math.random() * (max - min + 1) + min) } const rndInt = randomIntFromInterval(1, 6) console.log(rndInt )

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

---

重要的

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

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

在哪里：

1 是起始编号

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

---

数学随机（）

返回介于 min (included) 和 max (included) 之间的 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() 不提供密码安全的随机数。不要将它们用于与安全相关的任何事情。请改用 Web Crypto API，更准确地说是 window.crypto.getRandomValues() 方法。

---

其他解决方案：

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

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

Try online

---

TL;博士

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

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

下面的解释

integer - A number which is not a fraction; a whole number

我们需要得到一个随机数，比如 X 介于 min 和 max 之间。 X, min and max are all integers

即最小值 <= X <= 最大值

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

<= (X - min) <= (max - min)

现在，让我们将其与随机数 r 相乘，即

<= (X - min) * r <= (max - min) * r

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

min <= min + (X - min) * r <= min + (max - min) * r

对于任何给定的 X，仅当 r 的范围为 [0,1] 时，上述方程才满足。对于任何其他 r 值，上述方程都不满足。

Learn more about ranges [x,y] or (x,y) here

我们的下一步是找到一个函数，它总是产生一个范围为 [0,1] 的值

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

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

使用 Math.random() 的随机函数 0 <= r < 1

请注意，在 Math.random() 中，左边界是包含的，而右边界是排除的。这意味着 min + (max - min) * r 将评估为具有从 [min, max)

为了包括我们的右边界，即[min,max]，我们将右边界增加 1 并将结果取底。

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

获取随机数

generateRandomInteger(-20, 20);

---

或者，在 Underscore

_.random(min, max)

---

var x = 6; // can be any number
var rand = Math.floor(Math.random()*x) + 1;

---

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

---

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

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)

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

---

获取 0 到 400 之间的随机整数

让 rand = Math.round(Math.random() * 400) document.write(rand)

获取 200 到 1500 之间的随机整数

让 range = {min: 200, max: 1500} 让 delta = range.max - range.min const 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))

---

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

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

---

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

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

固定版本。

---

例子

返回 1 到 10 之间的随机数：

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

结果可能是：3

尝试一下：here

--

或使用 lodash / undescore：

_.random(min, max)

文档：- lodash - undescore

---

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

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

---

评分最高的解决方案在数学上与它下面的评论不同 -> 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 的 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：即使是评分最高的答案下的评论也是不正确的，因为人们忘记在差值上加 1，这意味着他们永远不会得到上限（是的，如果他们根本不想得到它可能是这种情况，但是要求是包括上边界）。

---

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

代码：

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

---

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;常量 maxGeneratedValue = 0xFFFFFFFF;常量可能结果值 = 范围 + 1；常量可能生成值 = 最大生成值 + 1； const 余数 = possibleGeneratedValues % possibleResultValues; const maxUnbiased = maxGeneratedValue - 余数； if (!Number.isInteger(min) || !Number.isInteger(max) || max > Number.MAX_SAFE_INTEGER || min < Number.MIN_SAFE_INTEGER) { throw new Error('参数必须是安全整数。'); } 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; } 让生成；做 { 生成 = crypto.getRandomValues(new Uint32Array(1))[0]; } 而（生成 > maxUnbiased）； return min + (生成的 % possibleResultValues); }; console.log(randomInteger(-8, 8)); // -2 console.log(randomInteger(0, 0)); // 0 console.log(randomInteger(0, 0xFFFFFFFF)); // 944450079 console.log(randomInteger(-1, 0xFFFFFFFF)); // 错误：从 -1 到 4294967295 的 4294967296 范围 > 4294967295。console.log(new Array(12).fill().map(n => randomInteger(8, 12))); // [11, 8, 8, 11, 10, 8, 8, 12, 12, 12, 9, 9]

---

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

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

---

根据@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

---

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

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

---

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

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

---

这应该有效：

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

---

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

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

---

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

rando(1, 6)

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

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

---

尝试使用：

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

---

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

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

---

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

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

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

---

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

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

代替

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

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

---

对于大数字。

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

---

对于邮递员： pm.environment.set("random_number", _.random(11111111111, 99999999999))

---