有没有办法在JavaScript中生成指定范围（例如1到6：1、2、3、4、5或6）内的随机数？

重要

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

如果您想获得介于1（只有1）和6 之间的随机整数，则可以计算：

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

哪里：

• 1是起始号码
• 6是可能的结果数（1 +开始（6） -结束（1））

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

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

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

在线尝试

TL; DR

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

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

解释如下

我们需要获得一个随机整数，例如介于最小值和最大值之间的X。

对？

即 min <= X <= max

如果我们从方程式中减去最小值，则等于

0 <=（X-最小）<=（最大-最小）

现在，乘这让一个随机数[R 是

0 <=（X-最小）* r <=（最大-最小）* r

现在，让min添加回方程

最小<=最小+（X-最小）* r <=最小+（最大-最小）* r

现在，让我们选择一个得出r的函数，使其满足我们的方程范围为[min，max]。仅当0 <= r <= 1时才有可能

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

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

例如，

情况r = 0

min+ 0 *（max- min）= 分钟

情况r = 1

min+1 *（max- min）= 最大值

使用Math.random的随机情况0 <= r <1

min+ r *（max- min）= X，其中X的范围为min <= X < max

上面的结果X是一个随机数字。但是由于Math.random（），我们的左边界是包含在内的，而右边界是排斥的。为了包括我们的右边界，我们将右边界增加1并下限结果。

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

获取随机数

generateRandomInteger(-20, 20);

或者，在下划线

_.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/zh-CN/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)

当然，您也可以添加一些验证，以确保除了数字以外不要使用其他任何方法。还要确保最小值始终小于或等于最大值。

我写了更灵活的函数，它可以为您提供随机数，而不仅仅是整数。

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

尝试一下：这里

-

或使用lodash / undescore：

_.random(min, max)

文档： - lodash - undescore

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

码：

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

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

    Rand(min: number, max: number): number {
        return (Math.random() * (max - min + 1) | 0) + 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如果需要更大的范围，可以将其修改为使用s。）无论选择哪个范围，被拒绝的生成值的分数将始终小于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]

float根据int@Francisc的答案中的版本添加具有固定精度的版本：

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

[a，b]范围内的加密强随机整数（假设：a <b）

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

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

这应该工作：

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

我发现了一种使用ES6默认参数执行此操作的好方法。这很漂亮，因为它允许一个参数或两个参数。这里是：

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

这大约晚了九年，但是randojs.com使这变得简单：

rando(1, 6)

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

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

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

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

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

尝试使用：

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

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

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