มีวิธีในการสร้างตัวเลขสุ่มในช่วงที่ระบุ (เช่นจาก 1 ถึง 6: 1, 2, 3, 4, 5 หรือ 6) ใน JavaScript หรือไม่

สิ่งสำคัญ

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

ส่งคืนตัวเลขสุ่มจำนวนเต็มระหว่างนาที ( รวม ) และสูงสุด ( รวมอยู่ด้วย ):

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

หรือตัวเลขสุ่มใด ๆระหว่างขั้นต่ำ ( รวม ) และสูงสุด ( ไม่รวม ):

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 และ max

ขวา?

ie min <= X <= สูงสุด

หากเราลบ min จากสมการนี่จะเท่ากับ

0 <= (X - นาที) <= (สูงสุด - นาที)

ทีนี้ลองคูณนี่ด้วยตัวเลขสุ่มr ซึ่งก็คือ

0 <= (X - นาที) * r <= (สูงสุด - นาที) * r

ทีนี้ลองเพิ่มนาทีกลับเข้าไปในสมการ

นาที <= นาที + (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 < สูงสุด

ผลลัพธ์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/

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

คณิตศาสตร์ไม่ใช่จุดแข็งของฉัน แต่ฉันได้ทำงานในโครงการที่ฉันต้องการสร้างตัวเลขสุ่มจำนวนมากระหว่างทั้งบวกและลบ

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)

Docs: - 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 บิตแทนเพราะนั่นเป็นขนาดจำนวนเต็มทั่วไปที่ใหญ่ที่สุดที่สามารถแสดงด้วยnumberชนิดมาตรฐานของ JavaScript (สิ่งนี้สามารถแก้ไขเพื่อใช้BigInts หากคุณต้องการช่วงที่ใหญ่กว่า) โดยไม่คำนึงถึงช่วงที่เลือกเศษส่วนของค่าที่สร้างขึ้นที่ถูกปฏิเสธจะน้อยกว่า 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, ...

และสำหรับคำตอบที่แท้จริง

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>

สิ่งนี้ใช้ได้สำหรับฉันและสร้างค่าเช่นฟังก์ชันไลบรารีมาตรฐานrandom.randintของ Python :

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