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

 2019-04-29 

Generate random number between two numbers in JavaScript

在javascript中,是否有一种方法可以在指定的范围内(例如从1到6:1、2、3、4、5或6)生成随机数?


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

它的"额外"功能是允许不以1开头的随机间隔。例如,你可以得到一个从10到15的随机数。灵活性。


如果你想在1到6之间,你可以计算:

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

在哪里?

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


数学,随机化()

从Mozilla Developer Network文档中:

1
2
3
// Returns a random integer between min (include) and max (include)

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

有用的例子:

1
2
3
4
5
6
7
8
9
10
11
// 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;


其他解决方案:

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


铊;博士

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

得到的随机数generateRandomInteger(-20, 20);

下面的解释

我们需要得到一个随机整数,x min和max之间的说。

右吗?

即min≤x<=max

如果我们为减从方程,这是等价的。

=(0<x<=min)(最大最小)

现在,让这一个随机数R的乘积这是

=(0<x<=min)×R×R(最大最小)

现在,添加后的Freundlich方程为min

min≤min(x min)+ * +(R<=min max min)×R

现在,我们有一个搜索功能的结果在R,它是满足的方程范围[分钟]。这是唯一可能的,如果0≤r≤1

好的。现在,R [0,1]范围即是非常类似于math.random()函数的结果。不是吗?

The Math.random() function returns a floating-point, pseudo-random
number in the range [0, 1); that is, from 0 (inclusive) up to but not
including 1 (exclusive)

例如,

凯斯R=0

min0 + *(max- min)= min

凯斯R=1

min+ 1 *(max- min)= max

使用随机案例math.random 0<r<1

min+ R *(max- min)= X,在X安切洛蒂范围≤x<max min

上面的X是一个随机数字的结果。然而,由于math.random(左)的绑定和绑定的是包容,是独家的权利。我们结合我们的权利包括增加1和地板是由结合的结果。

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

得到的随机数

generateRandomInteger(-20, 20)


或者,在下划线中

1
_.random(min, max)


jsfiddle:http:/ / / / / jsfiddle.net cygwf 477

随机数之间的随机整数:Get a minmax,使用下面的代码

1
2
3
4
5
function getRandomInteger(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min)) + min;
}

随机浮点数:to get a随机浮点数之间的数minmax,使用下面的代码

1
2
3
function getRandomFloat(min, max) {
  return Math.random() * (max - min) + min;
}

参考:http://developer.mozilla.org / EN /文档/网络/美国/全球_ JavaScript参考/对象/数学/随机


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


数学不是我的强项,但我一直在做一个项目,在这个项目中,我需要生成很多介于正负之间的随机数。

1
2
3
4
5
6
7
function randomBetween(min, max) {
    if (min < 0) {
        return min + Math.random() * (Math.abs(min)+max);
    }else {
        return min + Math.random() * max;
    }
}

例如

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

当然,您也可以添加一些验证,以确保您不使用除数字以外的其他任何内容。还要确保Min始终小于或等于Max。


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

1
2
3
4
5
6
7
8
9
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之间的随机数:

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

结果可能是:3

试试你自己:这里

——

或使用Lodash/Undescore:

_.random(min, max)

Docs:-落叶-非核心


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

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

答案很多,结果几乎一样。我想补充我的答案并解释它的工作原理。因为理解它的工作而不是复制粘贴一行代码是很重要的。生成随机数只不过是简单的数学。

代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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));
}

添加一个固定float精密版基于int版@ Francisc的回答:

1
2
3
4
5
6
function randomFloatFromInterval (min, max, fractionDigits) {
  const fractionMultiplier = Math.pow(10, fractionDigits)
  return Math.round(
    (Math.random() * (max - min) + min) * fractionMultiplier,
  ) / fractionMultiplier
}

是这样的:

1
randomFloatFromInterval(1,3,4) // => 2.2679, 1.509, 1.8863, 2.9741, ...

int和答案

1
randomFloatFromInterval(1,3,0) // => 1, 2, 3

感觉你需要在最大数上加1,然后减去最小数,这其中任何一个都可以工作,我需要做很多随机整数,这个函数可以工作。

1
2
3
4
var random = function(max, min) {
    high++;
    return Math.floor((Math.random()) * (max - min)) + min;
};

这同时适用于负数和正数,我正在为一个库处理小数。


Math.random()快速且适用于许多目的,但如果您需要密码安全值(它不安全),或者如果您需要完全一致的无偏分布的整数(其他答案中使用的乘法方法产生某些值的频率略高于其他方法),则不适用。

在这种情况下,我们可以使用crypto.getRandomValues()生成安全整数,并拒绝任何生成的不能统一映射到目标范围的值。这将变慢,但除非生成的值数量非常大,否则它不应该很重要。

为了澄清有偏分布的问题,考虑这样一种情况,我们希望生成1到5之间的值,但是我们有一个随机数生成器,它生成1到16之间的值(4位值)。我们希望有相同数量的生成值映射到每个输出值,但是16不能平均除以5:它留下1的余数。因此,我们需要拒绝可能生成的值中的1个,并且只有当我们得到可以统一映射到目标范围的15个较小的值之一时才能继续。我们的行为可能看起来像这样的伪代码:

1
2
3
4
5
6
7
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;您不必担心它永远循环。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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]


我发现上面的francisc解决方案没有在结果中包含最小或最大值,所以我这样修改了它:

1
2
3
4
function randomInt(min,max)
{
    return Math.floor(Math.random()*(max-(min+1))+(min+1));
}