在 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) } const rndInt = randomIntFromInterval(1, 6) console.log(rndInt)

它的“額外”功能是允許不以 1 開頭的隨機間隔。因此，例如，您可以獲得 10 到 15 之間的隨機數。 靈活性。

Answer 2

重要的

以下代碼僅在最小值為“1”時才有效。 它不適用於除“1”以外的最小值。

如果你想得到一個介於 1（並且只有 1 ）和 6 之間的隨機整數，你可以計算：

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

在哪里：

• 1 是起始編號
• 6 是可能的結果數 (1 + start (6) - end (1) )

Answer 3

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() 方法。

Answer 4

其他解決方案：

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

在線試用

Answer 5

TL; 博士

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

獲取隨機數generateRandomInteger(-20, 20);

解釋如下

我們需要得到一個隨機整數，比如最小值和最大值之間的X。

對？

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

如果我們從等式中減去 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的范圍即 [0,1] 與 Math.random() 函數結果非常相似。 不是嗎？

Math.random() 函數返回 [0, 1) 范圍內的浮點偽隨機數； 即，從 0（含）到但不包括 1（不含）

例如，

案例 r = 0

min + 0 * ( max - min ) = 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

或者，在下划線

_.random(min, max)

Answer 7

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

Answer 8

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

Random Floating Point Number : 要獲得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 9

數學不是我的強項，但我一直在做一個項目，我需要在正負之間生成大量隨機數。

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 10

ES6 / Arrow 函數版本基於 Francis 的代碼（即最佳答案）：

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

Answer 11

我寫了更靈活的函數，它可以給你隨機數，但不僅僅是整數。

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 12

例子

返回 1 到 10 之間的隨機數：

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

結果可能是： 3

試試自己： 在這里

——

或使用 lodash / undescore：

_.random(min, max)

文檔： - lodash - undescore

Answer 13

我正在搜索用 TypeScript 編寫的隨機數生成器，在閱讀了所有答案后我寫了這篇文章，希望它適用於 TypeScript 編碼人員。

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

Answer 14

這支持負整數：

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

Answer 15

一個簡單的單襯：

Math.floor( Math.random() * MAX_NUMBER ) + MIN_NUMBER

例如：

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

Answer 16

盡管有很多答案和幾乎相同的結果。 我想添加我的答案並解釋它的工作原理。 因為理解它的工作原理而不是復制粘貼一行代碼很重要。 生成隨機數只不過是簡單的數學運算。

代碼：

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 17

評分最高的解決方案在數學上並不像它下面的評論那樣正確 -> 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 乘以 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

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 19

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

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

Answer 20

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

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

使用隨機函數，可重復使用。

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

Answer 23

這應該有效：

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

Answer 24

范圍 [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 25

這大約晚了九年，但randojs.com使它成為一個簡單的單行：

rando(1, 6)

你只需要將它添加到你的 html 文檔的頭部，你就可以輕松地隨心所欲地做任何你想做的事情。 來自數組的隨機值、隨機的 jquery 元素、來自對象的隨機屬性，甚至在需要時防止重復。

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

Answer 26

嘗試使用：

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

Answer 27

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

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

代替

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

我們不要忘記其他有用的數學方法。

Answer 28

我發現了一種使用 ES6 默認參數的好方法。 它非常漂亮，因為它允許一個參數或兩個參數。 這里是：

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

Answer 29

這對我有用並產生像 Python 的random.randint標准庫函數這樣的值：

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

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

Answer 30

獲取0到400之間的隨機整數

 var rand = Math.round(Math.random() * 400); console.log(rand);

獲取200到1500之間的隨機整數

 var range = {min: 200, max: 1500}, delta = range.max - range.min, rand = Math.round(range.min + Math.random() * delta); console.log(rand);

Answer 31

為大數。

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

Answer 32

對於郵遞員： pm.environment.set("random_number", _.random(11111111111, 99999999999))

"

Answer 33

簡短的回答：使用簡單的數組可以實現。

您可以在數組元素中交替。

即使您的值不是連續的，此解決方案也有效。 值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)];

Answer 34

我發現上面的Francisc解決方案沒有在結果中包含最小或最大數，因此我將其更改為：

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