Nasıl JavaScript, örneğin belirtilen iki değişken arasındaki rasgele tamsayılar oluşturabilir x = 4ve y = 8bir çıktılayacaktır herhangi 4, 5, 6, 7, 8?

Mozilla Geliştirici Ağı sayfasında bazı örnekler vardır :

/**
 * Returns a random number between min (inclusive) and max (exclusive)
 */
function getRandomArbitrary(min, max) {
    return Math.random() * (max - min) + min;
}

/**
 * Returns a random integer between min (inclusive) and max (inclusive).
 * The value is no lower than min (or the next integer greater than min
 * if min isn't an integer) and no greater than max (or the next integer
 * lower than max if max isn't an integer).
 * Using Math.round() will give you a non-uniform distribution!
 */
function getRandomInt(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

İşte arkasındaki mantık. Bu üç kişilik basit bir kuraldır:

Math.random()Number0 (dahil) ile 1 (hariç) arasında bir değer döndürür . Yani böyle bir aralığımız var:

[0 .................................... 1)

Şimdi, min(dahil) ile max(hariç) arasında bir sayı istiyoruz :

[0 .................................... 1)
[min .................................. max)

Math.random[Min, maks) aralığında yazışmayı almak için the tuşunu kullanabiliriz . Ancak, ilk önce minikinci aralıktan çıkararak sorunu biraz hesaba katmalıyız:

[0 .................................... 1)
[min - min ............................ max - min)

Bu şunları verir:

[0 .................................... 1)
[0 .................................... max - min)

Şimdi Math.randommuhabiri uygulayabilir ve hesaplayabiliriz. Rastgele bir sayı seçelim:

                Math.random()
                    |
[0 .................................... 1)
[0 .................................... max - min)
                    |
                    x (what we need)

Bu yüzden bulmak için şunları xyaparız:

x = Math.random() * (max - min);

Tekrar eklemeyi unutmayın min, böylece [min, maks) aralığında bir sayı elde ederiz:

x = Math.random() * (max - min) + min;

MDN'nin ilk işlevi buydu. İkincisi, minve maxikisi de dahil olmak üzere tam sayı döndürür .

Şimdi tamsayıları almak için round, ceilveya kullanabilirsiniz floor.

Sen kullanabilirsiniz Math.round(Math.random() * (max - min)) + minBu ancak olmayan bir eşit dağılımı sağlanabilir. Her ikisi de minve maxsadece yuvarlanma şansının yaklaşık yarısı var:

min...min+0.5...min+1...min+1.5   ...    max-0.5....max
└───┬───┘└────────┬───────┘└───── ... ─────┘└───┬──┘   ← Math.round()
   min          min+1                          max

Aralığın maxdışında tutulduğunda, yuvarlanma şansı daha da azdır min.

İle Math.floor(Math.random() * (max - min +1)) + minsize mükemmel hatta dağılıma sahip.

min.... min+1... min+2 ... max-1... max.... max+1 (is excluded from interval)
|        |        |         |        |        |
└───┬───┘└───┬───┘└─── ... ┘└───┬───┘└───┬───┘   ← Math.floor()
   min     min+1               max-1    max

Sen kullanamaz ceil()ve -1bu denklemde çünkü maxartık rulo için biraz daha az şansı vardı, ama sen (istenmeyen) dönebilirsiniz min-1çok sonuçlanır.

var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;

Math.random ()

Min ( dahil ) ile max ( dahil ) arasında bir tamsayı rasgele sayı döndürür :

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

Veya min ( dahil ) ve max ( dahil değil ) arasındaki herhangi bir rastgele sayı :

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

Yararlı örnekler (tamsayılar):

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

** Ve her zaman hatırlatılması güzel (Mozilla):

Math.random () şifreli olarak güvenli rasgele sayılar sağlamaz. Bunları güvenlikle ilgili hiçbir şey için kullanmayın. Bunun yerine Web Kripto API'sını ve daha doğrusu window.crypto.getRandomValues ​​() yöntemini kullanın.

function getRandomizer(bottom, top) {
    return function() {
        return Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom;
    }
}

kullanımı:

var rollDie = getRandomizer( 1, 6 );

var results = ""
for ( var i = 0; i<1000; i++ ) {
    results += rollDie() + " ";    //make a string filled with 1000 random numbers in the range 1-6.
}

Yıkmak:

Biz çağrıldığında, değerler bottomve topdahil olmak üzere rastgele bir tamsayı döndürecek bir işlevi (fonksiyonel programlamadan borçlanma) döndürüyoruz . 'Kapsayıcı' diyoruz çünkü hem altta hem de üstte döndürülebilecek sayı aralığını dahil etmek istiyoruz. Bu şekilde getRandomizer( 1, 6 )1, 2, 3, 4, 5 veya 6 değerini döndürür.

(alt sayı daha düşük, üst sayı daha büyük)

Math.random() * ( 1 + top - bottom )

Math.random()0 ile 1 arasında rastgele çift verir ve biz çarpın o arasındaki bir artı farka göre eğer topve bottombiz arasında bir çift bir yere alırsınız 0ve 1+b-a.

Math.floor( Math.random() * ( 1 + top - bottom ) )

Math.floorsayıyı en yakın tam sayıya yuvarlar. Şimdi arasındaki tüm tamsayılar olması Yani 0ve top-bottom. 1 kafa karıştırıcı görünüyor, ama orada olmalıyız çünkü her zaman aşağı yuvarlanıyoruz, bu yüzden üst sayıya asla onsuz ulaşılamayacak. Biz ihtiyaçlarını üretmek rastgele ondalık aralığında olması 0için (1+top-bottom)Menzile bir int aşağı yuvarlamak ve alabilmeniz 0içintop-bottom

Math.floor( Math.random() * ( 1 + top - bottom ) ) + bottom

Önceki örnekteki kod bize aralıkta bir tamsayı verdi 0ve top-bottombu yüzden şimdi tek yapmanız gereken bottomaralıkta bottomve topkapsayıcıda bir tamsayı elde etmek için bu sonuca eklemek . : D

NOT: Tamsayı olmayan bir değer veya daha büyük bir sayıdan geçerseniz, istenmeyen davranışlar elde edersiniz, ancak herhangi biri talep etmediği sürece, orijinal sorunun amacından çok uzak olduğu için argüman kontrol koduna girmeyeceğim. .

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

Underscore.js kullanıyorsanız alternatif olarak kullanabilirsiniz

_.random(min, max)

1 ile 10 arasında rastgele bir sayı döndürün:

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

1 ile 100 arasında rastgele bir sayı döndür:

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

0 ile maks arasında bir değişkene ihtiyacınız varsa şunları kullanabilirsiniz:

Math.floor(Math.random() *  max);

Diğer cevaplar mükemmel makul parametreleri hesaba katmaz 0ve 1. Bunun yerine kullanmalısınız round yerine ait ceilveya floor:

function randomNumber(minimum, maximum){
    return Math.round( Math.random() * (maximum - minimum) + minimum);
}

console.log(randomNumber(0,1));  # 0 1 1 0 1 0
console.log(randomNumber(5,6));  # 5 6 6 5 5 6
console.log(randomNumber(3,-1)); # 1 3 1 -1 -1 -1

İşte Javascript'te Rasgele sınıfın MS DotNet uygulaması

var Random = (function () {
function Random(Seed) {
    if (!Seed) {
        Seed = this.milliseconds();
    }
    this.SeedArray = [];
    for (var i = 0; i < 56; i++)
        this.SeedArray.push(0);
    var num = (Seed == -2147483648) ? 2147483647 : Math.abs(Seed);
    var num2 = 161803398 - num;
    this.SeedArray[55] = num2;
    var num3 = 1;
    for (var i_1 = 1; i_1 < 55; i_1++) {
        var num4 = 21 * i_1 % 55;
        this.SeedArray[num4] = num3;
        num3 = num2 - num3;
        if (num3 < 0) {
            num3 += 2147483647;
        }
        num2 = this.SeedArray[num4];
    }
    for (var j = 1; j < 5; j++) {
        for (var k = 1; k < 56; k++) {
            this.SeedArray[k] -= this.SeedArray[1 + (k + 30) % 55];
            if (this.SeedArray[k] < 0) {
                this.SeedArray[k] += 2147483647;
            }
        }
    }
    this.inext = 0;
    this.inextp = 21;
    Seed = 1;
}
Random.prototype.milliseconds = function () {
    var str = new Date().valueOf().toString();
    return parseInt(str.substr(str.length - 6));
};
Random.prototype.InternalSample = function () {
    var num = this.inext;
    var num2 = this.inextp;
    if (++num >= 56) {
        num = 1;
    }
    if (++num2 >= 56) {
        num2 = 1;
    }
    var num3 = this.SeedArray[num] - this.SeedArray[num2];
    if (num3 == 2147483647) {
        num3--;
    }
    if (num3 < 0) {
        num3 += 2147483647;
    }
    this.SeedArray[num] = num3;
    this.inext = num;
    this.inextp = num2;
    return num3;
};
Random.prototype.Sample = function () {
    return this.InternalSample() * 4.6566128752457969E-10;
};
Random.prototype.GetSampleForLargeRange = function () {
    var num = this.InternalSample();
    var flag = this.InternalSample() % 2 == 0;
    if (flag) {
        num = -num;
    }
    var num2 = num;
    num2 += 2147483646.0;
    return num2 / 4294967293.0;
};
Random.prototype.Next = function (minValue, maxValue) {
    if (!minValue && !maxValue)
        return this.InternalSample();
    var num = maxValue - minValue;
    if (num <= 2147483647) {
        return parseInt((this.Sample() * num + minValue).toFixed(0));
    }
    return this.GetSampleForLargeRange() * num + minValue;
};
Random.prototype.NextDouble = function () {
    return this.Sample();
};
Random.prototype.NextBytes = function (buffer) {
    for (var i = 0; i < buffer.length; i++) {
        buffer[i] = this.InternalSample() % 256;
    }
};
return Random;
}());

kullanın:

        var r = new Random();
        var nextInt = r.Next(1, 100); //returns an integer between range
        var nextDbl = r.NextDouble(); //returns a random decimal

Belirli bir aralık arasında rasgele sayılar elde etmek için bu işlevi kullanın

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

Bir bilgisayar programı kullanarak rastgele bir sayı oluşturduktan sonra, seçilen sayı başlangıç ​​numarasının bir parçası veya tamamı ise rastgele bir sayı olarak kabul edilir. Ancak değiştirildiyse, matematikçiler bunu rastgele bir sayı olarak kabul etmezler ve buna önyargılı bir sayı diyebilirler. Ancak basit bir görev için bir program geliştiriyorsanız, bu dikkate alınması gereken bir durum olmayacaktır. Ancak, piyango programı veya kumar oyunu gibi değerli şeyler için rastgele bir sayı üretmek üzere bir program geliştiriyorsanız, yukarıdaki durum hakkında düşünmüyorsanız, programınız yönetim tarafından reddedilecektir.

Bu tür insanlar için benim önerim:

Düğmesini kullanarak rastgele bir sayı oluşturun Math.random(). (Bunu söyleyin n)

Now for [0,10) ==>  n*10 (i.e. one digit) and for[10,100) ==> n*100 (i.e. two digits) and so on. Here squire bracket indicates that boundary is inclusive and round bracket indicates boundary is exclusive.
Then remove the rest after the decimal point. (i.e. get floor) - using Math.floor(), this can be done.

Rastgele bir sayı seçmek için rasgele sayı tablosunu nasıl okuyacağınızı biliyorsanız, yukarıdaki işlemin (1, 10, 100 vb. İle çarpılması) başlangıçta bahsettiğim tabloyu ihlal etmediğini biliyorsunuzdur (çünkü yalnızca ondalık noktasının yeri.)

Aşağıdaki örneği inceleyin ve ihtiyaçlarınıza göre geliştirin.

Eğer bir örneğe ihtiyacınız varsa [0,9] o zaman n * 10 katı cevabınızdır ve gerekirse [0,99] da n * 100 katı cevabınızdır.

Şimdi rolünüze girelim:

Belirli aralıkta sayılar istediniz. (Bu durumda, bu aralık arasında yanlısınız. - Bir kalıp yuvarlayarak [1,6] 'dan bir sayı alarak, [1,6]' ya önyargılı olursunuz, ancak yine de, ancak kalıp tarafsızsa rastgele .)

Bu nedenle, aralığınızı düşünün ==> [78, 247] aralıktaki öğe sayısı = 247 - 78 + 1 = 170; (çünkü her iki sınır da kapsayıcıdır.

/*Mthod 1:*/
    var i = 78, j = 247, k = 170, a = [], b = [], c, d, e, f, l = 0;
    for(; i <= j; i++){ a.push(i); }
    while(l < 170){
        c = Math.random()*100; c = Math.floor(c);
        d = Math.random()*100; d = Math.floor(d);
        b.push(a[c]); e = c + d;
        if((b.length != k) && (e < k)){  b.push(a[e]); }
        l = b.length;
    }
    console.log('Method 1:');
    console.log(b);
/*Method 2:*/

    var a, b, c, d = [], l = 0;
    while(l < 170){
        a = Math.random()*100; a = Math.floor(a);
        b = Math.random()*100; b = Math.floor(b);
        c = a + b;
        if(c <= 247 || c >= 78){ d.push(c); }else{ d.push(a); }
        l = d.length;
    }
    console.log('Method 2:');
    console.log(d);

Not: Birinci yöntemde, önce ihtiyacınız olan sayıları içeren bir dizi oluşturdum ve sonra bunları rasgele başka bir diziye koydum. İkinci yöntemde, sayıları rastgele oluşturun ve ihtiyacınız olan aralıkta olup olmadığını kontrol edin. Sonra bir diziye koyun. Burada iki rasgele sayı ürettim ve toplamını, yararlı bir sayı elde eden arıza oranını en aza indirerek programın hızını en üst düzeye çıkarmak için kullandım. Bununla birlikte, üretilen sayıların eklenmesi de biraz biassness verecektir. Bu nedenle, belirli bir aralıkta rasgele sayılar üretmek için ilk yöntemimi öneririm.

Her iki yöntemde de konsolunuz sonucu gösterir. (Konsolu açmak için Chrome'da f12 tuşuna basın)

Aralıklı rastgele bir tam sayı için şunu deneyin:

function random(minimum, maximum) {
  var bool = true;

  while (bool) {
    var number = (Math.floor(Math.random() * maximum + 1) + minimum);
    if (number > 20) {
      bool = true;
    } else {
      bool = false;
    }
  }

  return number;
}

function getRandomInt(lower, upper)
{
    //to create an even sample distribution
    return Math.floor(lower + (Math.random() * (upper - lower + 1)));

    //to produce an uneven sample distribution
    //return Math.round(lower + (Math.random() * (upper - lower)));

    //to exclude the max value from the possible values
    //return Math.floor(lower + (Math.random() * (upper - lower)));
}

Bu işlevi ve bu işlevin varyasyonlarını test etmek için aşağıdaki HTML / JavaScript'i bir dosyaya kaydedin ve bir tarayıcı ile açın. Kod , bir milyon işlev çağrısının dağılımını gösteren bir grafik üretecektir . Kod ayrıca kenar durumlarını da kaydeder; bu nedenle işlev, max değerinden büyük veya min değerinden küçük bir değer üretirse, you.will.know.about.it.

<html>
    <head>
        <script type="text/javascript">
        function getRandomInt(lower, upper)
        {
            //to create an even sample distribution
            return Math.floor(lower + (Math.random() * (upper - lower + 1)));

            //to produce an uneven sample distribution
            //return Math.round(lower + (Math.random() * (upper - lower)));

            //to exclude the max value from the possible values
            //return Math.floor(lower + (Math.random() * (upper - lower)));
        }

        var min = -5;
        var max = 5;

        var array = new Array();

        for(var i = 0; i <= (max - min) + 2; i++) {
          array.push(0);
        }

        for(var i = 0; i < 1000000; i++) {
            var random = getRandomInt(min, max);
            array[random - min + 1]++;
        }

        var maxSample = 0;
        for(var i = 0; i < max - min; i++) {
            maxSample = Math.max(maxSample, array[i]);
        }

        //create a bar graph to show the sample distribution
        var maxHeight = 500;
        for(var i = 0; i <= (max - min) + 2; i++) {
            var sampleHeight = (array[i]/maxSample) * maxHeight;

            document.write('<span style="display:inline-block;color:'+(sampleHeight == 0 ? 'black' : 'white')+';background-color:black;height:'+sampleHeight+'px">&nbsp;[' + (i + min - 1) + ']:&nbsp;'+array[i]+'</span>&nbsp;&nbsp;');
        }
        document.write('<hr/>');
        </script>
    </head>
    <body>

    </body>
</html>

Rastgele bir sayı elde etmek için 1 ile 6 arasında deyin, önce yapın:

    0.5 + (Math.random() * ((6 - 1) + 1))

Bu, rasgele bir sayıyı 6 ile çarpar ve buna 0,5 ekler. Sonra sayıyı yaparak pozitif bir tam sayıya yuvarlayın:

    Math.round(0.5 + (Math.random() * ((6 - 1) + 1))

Bu sayıyı en yakın tam sayıya yuvarlar.

Veya bunu daha anlaşılır hale getirmek için şunları yapın:

    var value = 0.5 + (Math.random() * ((6 - 1) + 1))
    var roll = Math.round(value);
    return roll;

Genel olarak değişkenleri kullanarak bunu yapmak için kod:

    var value = (Min - 0.5) + (Math.random() * ((Max - Min) + 1))
    var roll = Math.round(value);
    return roll;

Minimum değerden 0,5 almanın nedeni, yalnızca minimum değeri kullanmanın maksimum değerinizden bir tam sayı elde etmenize izin vermesidir. Minimum değerden 0,5 alarak, maksimum değerin yuvarlanmasını önlersiniz.

Umarım yardımcı olur.

Aşağıdaki kodu kullanarak, belirli bir aralıkta tekrar etmeden rastgele sayılar dizisi oluşturabilirsiniz.

function genRandomNumber(how_many_number,min,max) {

            // parameters
            // how_many_number : how many numbers you want to generate. For example it is 5.
            // min(inclusive) : minimum/low value of a range. it must be any positive integer but less than max. i.e 4
            // max(inclusive) : maximun value of a range. it must be any positive integer. i.e 50
            // return type: array

            var random_number = [];
            for (var i = 0; i < how_many_number; i++) {
                var gen_num = parseInt((Math.random() * (max-min+1)) + min);
                do {
                    var is_exist = random_number.indexOf(gen_num);
                    if (is_exist >= 0) {
                        gen_num = parseInt((Math.random() * (max-min+1)) + min);
                    }
                    else {
                        random_number.push(gen_num);
                        is_exist = -2;
                    }
                }
                while (is_exist > -1);
            }
            document.getElementById('box').innerHTML = random_number;
        }

Bu sorunun zaten cevaplandığını biliyorum ama cevabım birine yardımcı olabilir.

Bu basit yöntemi W3Schools üzerinde buldum:

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

Umarım bu birisine yardım eder.

En düşük ve en yüksek arasında rastgele tam sayı:

function randomRange(l,h){
  var range = (h-l);
  var random = Math.floor(Math.random()*range);
  if (random === 0){random+=1;}
  return l+random;
}

En zarif çözüm değil .. ama hızlı bir şey.

İşte rastgele sayılar üretmek için kullandığım.

function random(high,low) {
    high++;
    return Math.floor((Math.random())*(high-low))+low;
}

Yürütüyoruz high++çünkü Math.random()0, (dahil) ve 1 (hariç) arasında rastgele bir sayı üretir. Hariç tutulan, herhangi bir matematik yapmadan önce en yüksek değeri bir artırmamız gerektiği anlamına gelir. Daha sonra düşükten yüksek çıkarırız, üretilecek en yüksek sayıyı veririz - düşük, sonra + düşük, yüksek seviyeyi normale döndürür ve en düşük sayıyı en az düşük yaparız. sonra elde edilen numarayı döndürürüz

random(7,3) geri dönebilir 3,4,5,6, or 7

    <!DOCTYPE html>
<html>
    <head>
            <meta charset="utf-8" />
    </head>
    <body>
        <script>
            /*

                assuming that window.crypto.getRandomValues is available
                the real range would be fron 0 to 1,998 instead of 0 to 2,000
                See javascript documentation for explanation
                https://developer.mozilla.org/en-US/docs/Web/API/RandomSource/getRandomValues
            */
            var array = new Uint8Array(2);
            window.crypto.getRandomValues(array);
            console.log(array[0] + array[1]);

        </script>
    </body>
</html>

Uint8Array, en fazla 999 olacak en fazla 3 basamaklı bir dizi oluşturur. Bu kod çok kısadır.

Math.random () kullanmadan belirtilen herhangi bir uzunlukta rastgele bir sayı oluşturabilen javascript işlevine bir örnek :

    function genRandom(length)
    {
     const t1 = new Date().getMilliseconds();
     var min = "1",max = "9";
     var result;
     var numLength = length;
     if (numLength != 0)
     {
        for (var i = 1; i < numLength; i++)
        {
           min = min.toString() + "0";
           max = max.toString() + "9";
        }
     } 
     else
     {
        min = 0;
        max = 0;
        return; 
     }

      for (var i = min; i <= max; i++)
      {
           //Empty Loop
      }

      const t2 = new Date().getMilliseconds();
      console.log(t2);
      result = ((max - min)*t1)/t2;
      console.log(result);
      return result;
    }

bu benim üssü rasgele bir sayıya almam, çünkü üsse üs bazında rasgele bir sayı almak istedim. örneğin base = 10, üs = 2, ideal olarak 0 ile 100 arasında rastgele bir sayı verir.

Kullanmaya yardımcı olursa, işte burada:

// get random number within provided base + exponent
// by Goran Biljetina --> 2012

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}
var numSeq = new Array();
function add(num,seq){
    var toAdd = new Object();
     toAdd.num = num;
     toAdd.seq = seq;
     numSeq[numSeq.length] = toAdd;
}
function fillNumSeq (num,seq){
    var n;
    for(i=0;i<=seq;i++){
        n = Math.pow(num,i);
        add(n,i);
    }
}
function getRandNum(base,exp){
    if (isEmpty(base)){
        console.log("Specify value for base parameter");
    }
    if (isEmpty(exp)){
        console.log("Specify value for exponent parameter");
    }
    fillNumSeq(base,exp);
    var emax;
    var eseq;
    var nseed;
    var nspan;
    emax = (numSeq.length);
    eseq = Math.floor(Math.random()*emax)+1;
    nseed = numSeq[eseq].num;
    nspan = Math.floor((Math.random())*(Math.random()*nseed))+1;
    return Math.floor(Math.random()*nspan)+1;
}

console.log(getRandNum(10,20),numSeq);
//testing:
//getRandNum(-10,20);
//console.log(getRandNum(-10,20),numSeq);
//console.log(numSeq);

Math.random() birçok amaç için hızlı ve uygundur, ancak kriptografik olarak güvenli değerlere ihtiyacınız varsa (güvenli değildir) veya tamamen tekdüze bir tarafsız dağıtımdan tamsayılara ihtiyacınız varsa (başkalarının cevaplarında kullanılan çarpma yaklaşımı biraz daha sık belirli değerler üretir) diğerlerine göre).

Bu gibi durumlarda, crypto.getRandomValues() güvenli tamsayılar oluşturmak ve hedef aralığa eşit olarak eşleştiremediğimiz oluşturulan değerleri reddetmek için kullanabiliriz. Bu daha yavaş olacaktır, ancak çok fazla değer üretmediğiniz sürece önemli olmamalıdır.

Önyargılı dağıtım endişesini açıklığa kavuşturmak için, 1 ile 5 arasında bir değer üretmek istediğimiz durumu düşünün, ancak 1 ile 16 arasında değerler üreten bir rastgele sayı üretecimiz var (4 bitlik bir değer). Her bir çıkış değeri ile aynı sayıda üretilen değere eşleme yapmak istiyoruz, ancak 16 eşit olarak 5'e bölünmüyor: 1'in geri kalanını bırakıyor. Bu nedenle, olası üretilen değerlerin 1'ini reddetmeliyiz ve yalnızca hedef aralığımıza eşit olarak eşlenebilen 15 küçük değerden biri. Davranışımız şu sahte kod gibi görünebilir:

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.

Aşağıdaki kod benzer mantık kullanır, ancak bunun yerine 32 bitlik bir tamsayı oluşturur, çünkü bu, JavaScript'in standart numbertürüyle temsil edilebilecek en büyük ortak tamsayı boyutudur . (Bu, BigIntdaha geniş bir aralığa ihtiyacınız varsa s kullanmak için değiştirilebilir .) Seçilen aralığa bakılmaksızın, reddedilen üretilen değerlerin oranı her zaman 0,5'ten az olur, bu nedenle beklenen reddetme sayısı her zaman 1,0'dan az olur ve genellikle 0.0'a yakın; sonsuza kadar döngü hakkında endişelenmenize gerek yok.

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]

Kripto-Güçlü

Ragne'de [x, y] kripto-kuvvetli rasgele tam sayı almak için

let cs= (x,y)=>x+(y-x+1)*crypto.getRandomValues(new Uint32Array(1))[0]/2**32|0

console.log(cs(4,8))

Bu kod snippet'ini yapabilirsiniz,

let randomNumber = function(first,second){
let number = Math.floor(Math.random()*Math.floor(second));
while(number<first){

    number = Math.floor(Math.random()*Math.floor(second));
}
return number;
}

Ionuț G. Stan harika bir cevap yazdı ama kavramak benim için biraz karmaşıktı. Bu yüzden, aynı kavramların daha basit bir açıklamasını https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation adresinde buldum. Jason Anello'da .

NOT: Jason'ın açıklamasını okumadan önce bilmeniz gereken tek önemli şey "kısaltma" tanımıdır. Bu terimi tanımlarken kullanır Math.floor(). Oxford sözlüğü "kısalt" kelimesini şu şekilde tanımlar:

Üst veya ucu keserek kısaltın (bir şey).

Bu, 20 basamaklı BENZERSİZ rastgele sayı üretmeyi başarabilir

JS

var generatedNumbers = [];

function generateRandomNumber(precision) { // precision --> number precision in integer 
    if (precision <= 20) {
        var randomNum = Math.round(Math.random().toFixed(precision) * Math.pow(10, precision));
        if (generatedNumbers.indexOf(randomNum) > -1) {
            if (generatedNumbers.length == Math.pow(10, precision))
                return "Generated all values with this precision";
                return generateRandomNumber(precision);
        } else {
            generatedNumbers.push(randomNum);
            return randomNum;
        }
    } else
       return "Number Precision shoould not exceed 20";
}
generateRandomNumber(1);

JsFiddle

/ * Bir randUpTosayıyı kabul eden ve 0 ile bu sayı arasında rastgele bir tam sayı döndüren adlı bir işlev yaz ? * /

var randUpTo = function(num) {
    return Math.floor(Math.random() * (num - 1) + 0);
};

/ * Bir randBetweenaralığı temsil eden iki sayıyı kabul eden ve bu iki sayı arasında rastgele bir tam sayı döndüren bir işlev yazın . * /

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

/ * Bir randFromTillaralığı temsil eden iki sayıyı kabul eden ve min (dahil) ile max (özel) arasında rastgele bir sayı döndüren bir işlev yazın . * /

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

/ * Bir randFromToaralığı temsil eden iki sayıyı kabul eden ve min (dahil) ile max (dahil) arasında rastgele bir tamsayı döndüren bir işlev yazın * /

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

Min, max, exclude (hariç tutmak için ints listesi) ve tohum (tohumlanmış bir rastgele jeneratör istiyorsanız) gibi seçenekleri dikkate alan bu işlevi yaptım.

get_random_int = function(args={})
{
    let def_args =
    {
        min: 0,
        max: 1,
        exclude: false,
        seed: Math.random
    }

    args = Object.assign(def_args, args)

    let num = Math.floor(args.seed() * (args.max - args.min + 1) + args.min)

    if(args.exclude)
    {
        let diff = args.max - args.min
        let n = num

        for(let i=0; i<diff*2; i++)
        {
            if(args.exclude.includes(n))
            {
                if(n + 1 <= args.max)
                {
                    n += 1
                }

                else
                {
                    n = args.min
                }
            }

            else
            {
                num = n
                break
            }
        }
    }

    return num
}

Gibi kullanılabilir:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1,
        exclude: [3, 6, 5],
        seed: my_seed_function
    }
)

Veya daha basit:

let n = get_random_int
(
    {
        min: 0,
        max: some_list.length - 1
    }
)

Sonra şunları yapabilirsiniz:

let item = some_list[n]

Gist: https://gist.github.com/madprops/757deb000bdec25776d5036dae58ee6e

• rastgele (min, maks) min (dahil) ve max (hariç) arasında rastgele bir sayı oluşturur

• Math.floor, bir sayıyı en yakın tam sayıya yuvarlar

  function generateRandomInteger (min, max) { 
      return Math.floor(random(min,max)) 
  }`

4 ve 8 (dahil) arasında rastgele bir tamsayı oluşturmak için yukarıdaki işlevi aşağıdaki bağımsız değişkenlerle çağırın:

generateRandomInteger (4,9)

0 ile n arasında rastgele sayı üretme yöntemim, burada n <= 10 (n hariç):

Math.floor((Math.random() * 10) % n)