重要

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

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

在哪里：

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

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

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

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

其他解决方案：

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

在线试用

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

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

e. g

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

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

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 -> 10Math.floor(Math.random() * 11);
// 1 -> 10Math.floor(Math.random() * 10) + 1;
// 5 -> 20Math.floor(Math.random() * 16) + 5;
// -10 -> (-2)Math.floor(Math.random() * 9) - 10;

**总是很高兴被提醒（Mozilla）：

Math.random（）不提供加密安全的随机不要将它们用于任何与安全有关的事情。使用网络而不是加密API，更准确地说window.crypto.get随机值（）方法。

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

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

或者，在下划线

_.random(min, max)

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

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, 10var b = rand(4,6,0.1); //can be 4.0, 4.1, 4.2 (...) 5.9, 6.0

固定版本。

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;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));          // -2console.log(randomInteger(0, 0));           // 0console.log(randomInteger(0, 0xFFFFFFFF));  // 944450079console.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]

示例

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

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

结果可能是：3

试试自己：这里

--

或使用洛塔什/undescore：

_.random(min, max)

文档：-豆沙-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-lowervar num = ((percent * (upper - lower) / 100));//num will now have a number that falls in your INTERVAL simple mathsnum += 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 possibleconsole.log(Math.floor(num), Math.ceil(num), Math.round(num));}

代码说明jsfiddle：https://jsfiddle.net/cyGwf/477/

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

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

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

解释如下

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

我们需要得到一个随机数，比如最小值和最大值之间的X。X, min and max are all integers

即min<=X<=max

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

0<=（X-min）<=（max-min）

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

0<=（X-min）*r<=（max-min）*r

现在，让我们将分钟添加到等式中

min<=min+（X-min）*r<=min+（max-min）*r

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

在此处了解有关范围[x， y]或（x， y）的更多信息

我们的下一步是找到一个函数，它总是产生一个范围为[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)；

基于@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

这应该工作：

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

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

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

加密强范围内的随机整数[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) );

像骰子一样返回1-6，

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

这大约晚了九年，但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));

此函数可以在（并包括）min和max数字之间生成一个随机整数：

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 3randomNumber(-5, -2); // can be -5, -4, -3 and -2randomNumber(0, 4); // can be 0, 1, 2, 3 and 4randomNumber(4, 0); // can be 0, 1, 2, 3 and 4

对于大数字。

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

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

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

最受好评的解决方案在数学上与它下面的评论不一样->Math.floor(Math.random() * 6) + 1。

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

Math.random()返回0和1之间的浮点数（例如0.344717274374或0.99341293123），我们将使用百分比，因此Math.floor(Math.random() * 6) + 1返回6的某些百分比（max： 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的期望边界。

所以，正确的逻辑是将下限和上限之间的差加上1，然后只对其进行下限（以减分1，因为Math.random()返回0-0.99，所以无法获得完整的上界，这就是为什么我们将1添加到上界以获得最大99%的（上界+1），然后我们对其进行下限以消除多余）。一旦我们得到（差+1）的下限百分比，我们可以添加下边界以获得2个数字之间所需的随机数字。

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

附言：即使是在最高评分答案下的评论也是不正确的，因为人们忘记在差异中添加1，这意味着他们永远不会得到向上边界（是的，如果他们根本不想得到它，这可能是一个案例，但要求包括上边界）。

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

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

如果起始数为1，如示例（1-6），则可以使用Math.ceil（）方法而不是Math.floor（）。

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

而不是

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

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

在和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 - minreturn Math.round(min + Math.random() * delta)}
document.write(randBetween(10, 15));

// JavaScript ES6 arrow function
const randBetween = (min, max) => {let delta = max - minreturn Math.round(min + Math.random() * delta)}
document.write(randBetween(10, 20))

简短回答：它可以使用一个简单的数组来实现。

您可以在数组元素内交替。

即使您的值不是连续，此解决方案也有效。值don't even have to be a number.

let array = [1, 2, 3, 4, 5, 6];const randomValue = array[Math.floor(Math.random() * array.length)];

如果你想覆盖消极和积极数字，并使其安全，然后使用以下内容：

js方案：

function generateRangom(low, up) {const u = Math.max(low, up);const l = Math.min(low, up);const diff = u - l;const r = Math.floor(Math.random() * (diff + 1)); //'+1' because Math.random() returns 0..0.99, it does not include 'diff' value, so we do +1, so 'diff + 1' won't be included, but just 'diff' value will be.  
return l + r; //add the random number that was selected within distance between low and up to the lower limit.}

Java解决方案：

public static int generateRandom(int low, int up) {int l = Math.min(low, up);int u = Math.max(low, up);int diff = u - l;
int r = (int) Math.floor(Math.random() * (diff + 1)); // '+1' because Math.random() returns 0..0.99, it does not include 'diff' value, so we do +1, so 'diff + 1' won't be included, but just 'diff' value will be.  
return l + r;//add the random number that was selected within distance between low and up to the lower limit.}

这个简单的功能很方便，适用于任何案件（完全测试）。此外，结果的分布已经过充分测试，100%正确。

function randomInteger(pMin = 1, pMax = 1_000_000_000)//Author: Axel Gauffre.//Here: https://stackoverflow.com/a/74636954/5171000//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);}