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

Question

有没有办法在JavaScript中生成指定范围内的随机数(例如1到6:1,2,3,4,5或6)？

Answer 1

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

它所做的"额外"是允许随机间隔不以1开头.因此,您可以获得10到15之间的随机数.灵活性.

Answer 2

如果你想得到1到6之间,你会计算:

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

哪里:

• 1是起始编号
• 6是可能结果的数量(1 + start (6) - end (1))

Answer 3

的Math.random()

从Mozilla Developer Network文档中:

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

Answer 4

其他方案:

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

Answer 5

TL; DR

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

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

下面的说明

我们需要得到一个随机整数,比如说min和max之间的X.

对？

即 min <= X <= max

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

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

现在,让我们用一个随机数乘以这个[R 是

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

现在,让我们将min添加到等式中

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

现在,让我们选择一个函数,它导致r满足我们的方程范围[min,max].这只有在0 <= r <= 1时才有可能

好.现在,r ie [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);

Answer 6

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

let rand = Math.round(Math.random() * 400)

document.write(rand)

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

let range = {min: 200, max: 1500}
let 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 arrow function

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

document.write(randBetween(10, 20))

Answer 7

或者,在Underscore中

_.random(min, max)

Answer 8

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

Answer 9

jsfiddle:https://jsfiddle.net/cyGwf/477/

Random Integer:获取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

Answer 10

数学不是我的强项,但我一直致力于一个项目,我需要在正面和负面之间产生大量的随机数.

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.

Answer 11

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

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

Answer 12

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

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

Answer 13

加密强

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

Answer 14

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

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

固定版本.

Answer 15

这支持负整数：

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

Answer 16

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]

Answer 17

评分最高的解决方案在数学上并不像它下面的评论那样正确 -> 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 时会出现问题。例如， Task: generate random between 2 and 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 添加到上限以获得最多 99% 的（上限 + 1），然后我们将其降低以去除多余的部分）。一旦我们得到了 (difference + 1) 的下限百分比，我们就可以添加下边界以获得 2 个数字之间所需的随机数。

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

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

Answer 18

例

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

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

结果可能是: 3

试试自己:这里

-

或使用lodash/unexcore:

_.random(min, max)

文档: - lodash - undescore

Answer 19

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

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

Answer 20

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

码：

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

Answer 21

该函数可以生成一个介于（含）最小和最大数之间的随机整数：

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

Answer 22

这个简单的功能很方便，可以在任何情况下使用（经过充分测试）。此外，结果的分布已经过充分测试，100%正确。

function randomInteger(pMin = 1, pMax = 1_000_000_000)
//Author: Axel Gauffre. 
//Here: /sf/answers/5224586811/
//Inspired by: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random#getting_a_random_number_between_two_values
//
//This function RETURNS A RANDOM INTEGER between pMin (INCLUDED) and pMax (INCLUDED).
//  - pMin and pMax should be integers.
//  - HOWEVER, if pMin and/or pMax are FLOATS, they will be ROUNDED to the NEAREST integer.
//  - NEGATIVE values ARE supported.
//  - The ORDER of the 2 arguments has NO consequence: If pMin > pMax, then pMin and pMax will simply be SWAPPED.
//  - If pMin is omitted, it will DEFAULT TO 1.
//  - If pMax is omitted, it will DEFAULT TO 1 BILLION.
//
//This function works in ANY cases (fully tested).
//Also, the distribution of the results has been fully tested and is 100% correct.
{
    pMin = Math.round(pMin);
    pMax = Math.round(pMax);
    if (pMax < pMin) { let t = pMin; pMin = pMax; pMax = t;}
    return Math.floor(Math.random() * (pMax+1 - pMin) + pMin);
}