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

Apa itu "tambahan" hal ini memungkinkan interval waktu yang acak yang tidak mulai dengan 1. Agar anda bisa mendapatkan nomor acak dari 10 sampai 15 misalnya. Fleksibilitas.

Penting

Jika anda ingin mendapatkan bilangan bulat acak antara 1 (**1***) dan 6, anda akan menghitung:

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

Dimana:

• 1 adalah nomor start
• 6 adalah jumlah hasil yang mungkin (1 + mulai (6) - end (1))

Matematika.random()

Dari Mozilla Pengembang Jaringan dokumentasi:

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

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

Berguna contoh:

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

Solusi lain:

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

Mencoba online

TL;DR

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

Untuk mendapatkan nomor acak generateRandomInteger(-20, 20);

PENJELASAN DI BAWAH INI

Kita perlu untuk mendapatkan bilangan bulat acak, mengatakan X antara min dan max.

Kan?

aku.e min <= X <= max

Jika kita kurangi menit dari persamaan ini setara dengan

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

Sekarang, mari kita kalikan ini dengan nomor acak r yang

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

Sekarang, mari kita tambahkan kembali min untuk persamaan

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

Sekarang, mari kita memilih fungsi yang menghasilkan r seperti yang memenuhi persamaan kami sebagai [min,max]. Ini hanya mungkin jika 0<= r <=1

OK. Sekarang, kisaran r i.e [0,1] adalah sangat mirip dengan Matematika.random() hasil fungsi. Isn't itu?

Matematika.random() fungsi mengembalikan floating-point, pseudo-random nomor dalam rentang [0, 1); bahwa, dari 0 (inklusif) sampai dengan tetapi tidak termasuk 1 (eksklusif)

Misalnya,

Kasus r = 0

min + 0 * (max-min) = min

Kasus r = 1

min + 1 * (max-min) = max

Kasus acak menggunakan Matematika.random 0 <= r < 1

min + r * (max-min) = X, dimana X memiliki jangkauan min <= X < max

Hasil diatas X adalah angka acak. Namun karena Matematika.random() kiri kita terikat adalah inklusif, dan hak terikat adalah eksklusif. Untuk memasukkan hak kita terikat kita meningkatkan hak terikat oleh 1 dan lantai hasil.

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

Untuk mendapatkan nomor acak

generateRandomInteger(-20, 20);

Atau, di Underscore

_.random(min, max)

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

Random Integer: untuk mendapatkan bilangan bulat acak antara min dan max, gunakan kode berikut

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

Acak Angka Floating Point: untuk mendapatkan acak angka floating point antara min dan max, gunakan kode berikut

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

Referensi: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random

Matematika bukan titik kuat saya, tapi saya've telah bekerja pada sebuah proyek di mana saya dibutuhkan untuk menghasilkan banyak acak angka antara positif dan negatif.

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)

Tentu saja, anda juga dapat menambahkan beberapa validasi untuk memastikan anda don't melakukan hal ini dengan sesuatu yang lain daripada angka-angka. Juga pastikan bahwa min selalu kurang dari atau sama dengan max.

Saya menulis lebih fleksibel fungsi yang dapat memberikan nomor acak tetapi tidak hanya integer.

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

Versi tetap.

Contoh

Kembali nomor acak antara 1 dan 10:

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

Hasilnya bisa menjadi: 3

Mencoba sendiri: di sini

--

atau menggunakan lodash / undescore:

_.random(min, max)

Docs:

• lodash
• undescore

Meskipun banyak jawaban dan hampir sama hasilnya. Saya ingin menambahkan jawaban saya dan menjelaskan kerja. Karena itu adalah penting untuk memahami kerja daripada copy paste satu baris kode. Menghasilkan angka acak adalah apa-apa tapi sederhana matematika.

KODE:

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

Aku sedang mencari nomor acak generator yang tertulis dalam Naskah dan saya telah menulis ini setelah membaca semua jawaban, berharap Itu akan bekerja untuk Naskah coders.

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

Menambahkan float dengan tetap presisi versi berdasarkan int versi di @Francisc's jawaban:

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

jadi:

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

dan untuk int jawaban

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

Matematika.random() adalah cepat dan cocok untuk banyak tujuan, tetapi itu's tidak tepat jika anda membutuhkan kriptografi yang aman nilai-nilai (it's tidak aman), atau jika anda membutuhkan bilangan bulat dari yang benar-benar seragam berisi distribusi (perkalian pendekatan yang digunakan dalam jawaban orang lain menghasilkan nilai-nilai tertentu sedikit lebih sering daripada yang lain).

Dalam kasus tersebut, kita dapat menggunakan kripto.getRandomValues() untuk menghasilkan aman bilangan bulat, dan menolak apa pun yang dihasilkan nilai-nilai yang bisa kita't peta seragam ke dalam kisaran target. Ini akan menjadi lebih lambat, tetapi seharusnya't menjadi signifikan kecuali anda're menghasilkan jumlah yang sangat besar dari nilai-nilai.

Untuk memperjelas bias distribusi kekhawatiran, pertimbangkan kasus di mana kita ingin menghasilkan nilai antara 1 dan 5, tapi kami memiliki nomor acak generator yang menghasilkan nilai antara 1 dan 16 (4-bit value). Kami ingin memiliki jumlah yang sama yang dihasilkan pemetaan nilai-nilai untuk masing-masing nilai output, tetapi 16 tidak merata dibagi dengan 5: meninggalkan sisa 1. Jadi kita perlu menolak 1 yang mungkin dihasilkan nilai-nilai, dan hanya terus ketika kita mendapatkan salah satu dari 15 nilai yang lebih rendah yang dapat seragam dipetakan ke dalam kisaran target. Perilaku kita bisa terlihat seperti ini pseudocode:

tidak ada Menghasilkan 4-bit integer dalam range 1-16. Jika kita dihasilkan 1, 6, atau 11 maka output 1. Jika kita menghasilkan 2, 7, 12 maka output 2. Jika kita dihasilkan 3, 8, atau 13 maka output 3. Jika kita dihasilkan 4, 9, atau 14 maka output 4. Jika kita dihasilkan 5, 10, atau 15 kemudian output 5. Jika kita menghasilkan 16 kemudian menolaknya dan mencoba lagi.

Kode berikut menggunakan logika mirip, tetapi menghasilkan 32-bit integer sebaliknya, karena yang's terbesar umum integer ukuran yang dapat diwakili oleh JavaScript's standar nomor jenis. (Ini bisa dimodifikasi untuk menggunakan `BigInt ini jika anda membutuhkan jangkauan yang lebih besar.) Terlepas dari pilihan yang dipilih, fraksi dihasilkan nilai-nilai yang ditolak akan selalu kurang dari 0,5, sehingga diharapkan jumlah penolakan akan selalu kurang dari 1.0 dan biasanya dekat dengan 0.0; anda don't perlu khawatir tentang hal itu looping selamanya.

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]

Ini harus bekerja:

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

Saya menemukan sebuah cara baru yang besar untuk melakukan hal ini menggunakan ES6 parameter default. Hal ini sangat bagus karena memungkinkan salah satu argumen atau dua argumen. Di sini adalah:

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

Crypto-kuat integer acak nomor di ragne [a,b] (asumsi: a < b )

let rand= (a,b)=> a+(b-a+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0

console.log(rand(1,6))

untuk kembali 1-6 seperti dadu pada dasarnya, kembali Matematika.round(Math.random() * 5 + 1);

Saya menemukan Francisc's solusi di atas tidak termasuk min atau max jumlah hasil, jadi aku berubah seperti ini:

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