Wie kann ich zufällige ganze Zahlen zwischen zwei angegebenen Variablen in JavaScript generieren, z. B. x = 4und y = 8eine davon ausgeben 4, 5, 6, 7, 8?

Auf der Seite Mozilla Developer Network finden Sie einige Beispiele :

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

Hier ist die Logik dahinter. Es ist eine einfache Dreierregel:

Math.random()Gibt a Numberzwischen 0 (einschließlich) und 1 (exklusiv) zurück. Wir haben also ein Intervall wie dieses:

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

Nun möchten wir eine Zahl zwischen min(inklusive) und max(exklusiv):

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

Wir können das verwenden Math.random, um den Korrespondenten im Intervall [min, max) zu erhalten. Aber zuerst sollten wir das Problem ein wenig berücksichtigen, indem wir minvom zweiten Intervall abziehen :

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

Das gibt:

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

Wir können uns jetzt bewerben Math.randomund dann den Korrespondenten berechnen. Wählen wir eine Zufallszahl:

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

Um zu finden x, würden wir tun:

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

Vergessen Sie nicht, etwas hinzuzufügen min, damit wir im Intervall [min, max) eine Zahl erhalten:

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

Das war die erste Funktion von MDN. Die zweite gibt eine Ganzzahl zwischen minund maxeinschließlich zurück.

Jetzt für ganze Zahlen bekommen, könnten Sie verwenden round, ceiloder floor.

Sie könnten verwenden Math.round(Math.random() * (max - min)) + min, dies ergibt jedoch eine ungleichmäßige Verteilung. Beide minund haben maxnur ungefähr die Hälfte der Chance zu würfeln:

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

Mit maxaus dem Intervall ausgeschlossen, hat es eine noch geringere Chance zu rollen als min.

Mit haben Math.floor(Math.random() * (max - min +1)) + minSie eine vollkommen gleichmäßige Verteilung.

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

Sie können ceil()und -1in dieser Gleichung nicht verwenden , da maxjetzt eine etwas geringere Chance zum Würfeln bestand, aber Sie können auch das (unerwünschte) min-1Ergebnis würfeln .

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

Math.random ()

Gibt eine ganzzahlige Zufallszahl zwischen min ( enthalten ) und max ( enthalten ) zurück:

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

Oder eine beliebige Zufallszahl zwischen min ( enthalten ) und max ( nicht enthalten ):

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

Nützliche Beispiele (ganze Zahlen):

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

** Und immer schön daran erinnert zu werden (Mozilla):

Math.random () bietet keine kryptografisch sicheren Zufallszahlen. Verwenden Sie sie nicht für Sicherheitszwecke. Verwenden Sie stattdessen die Web Crypto API und genauer die window.crypto.getRandomValues ​​() -Methode.

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

Verwendungszweck:

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

Nervenzusammenbruch:

Wir geben eine Funktion zurück (aus der funktionalen Programmierung entlehnt), die beim Aufruf eine zufällige Ganzzahl zwischen den Werten bottomund topeinschließlich zurückgibt. Wir sagen "inklusive", weil wir sowohl unten als auch oben in den Bereich der Zahlen aufnehmen möchten, die zurückgegeben werden können. Auf diese Weise getRandomizer( 1, 6 )wird entweder 1, 2, 3, 4, 5 oder 6 zurückgegeben.

(unten ist niedrigere Zahl, oben ist größere Zahl)

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

Math.random()Gibt ein zufälliges Doppel zwischen 0 und 1 zurück. Wenn wir es mit eins plus der Differenz zwischen topund multiplizieren bottom, erhalten wir irgendwo zwischen 0und ein Doppel 1+b-a.

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

Math.floorrundet die Zahl auf die nächste ganze Zahl ab. Wir haben jetzt alle ganzen Zahlen zwischen 0und top-bottom. Die 1 sieht verwirrend aus, muss aber vorhanden sein, da wir immer abrunden, sodass die höchste Zahl ohne sie eigentlich nie erreicht wird. Die zufällige Dezimalstelle, die wir generieren, muss im Bereich 0bis liegen , (1+top-bottom)damit wir abrunden und ein Int im Bereich 0bis erhalten könnentop-bottom

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

Der Code im vorherigen Beispiel gab uns eine ganze Zahl im Bereich 0und top-bottom, so alles , was wir jetzt tun müssen , ist hinzuzufügen , bottomzu diesem Ergebnis eine ganze Zahl im Bereich zu bekommen bottomund topinklusive. : D.

HINWEIS: Wenn Sie zuerst einen nicht ganzzahligen Wert oder die größere Zahl übergeben, erhalten Sie unerwünschtes Verhalten. Wenn jedoch niemand dies anfordert, werde ich mich nicht mit dem Code zur Argumentprüfung befassen, da er weit von der Absicht der ursprünglichen Frage entfernt ist .

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

Alternativ, wenn Sie Underscore.js verwenden , können Sie verwenden

_.random(min, max)

Geben Sie eine Zufallszahl zwischen 1 und 10 zurück:

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

Geben Sie eine Zufallszahl zwischen 1 und 100 zurück:

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

Wenn Sie eine Variable zwischen 0 und max benötigen, können Sie Folgendes verwenden:

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

Die anderen Antworten berücksichtigen nicht die völlig vernünftigen Parameter von 0und 1. Verwenden Sie round stattdessen anstelle von ceiloder 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

Hier ist die MS DotNet-Implementierung der Zufallsklasse in Javascript-

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

Verwenden:

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

Verwenden Sie diese Funktion, um Zufallszahlen zwischen bestimmten Bereichen zu erhalten

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

Nach dem Generieren einer Zufallszahl mit einem Computerprogramm wird immer noch als Zufallszahl betrachtet, ob die ausgewählte Zahl ein Teil oder die vollständige der ursprünglichen Zahl ist. Wenn es jedoch geändert wurde, akzeptieren Mathematiker es nicht als Zufallszahl und können es als voreingenommene Zahl bezeichnen. Wenn Sie jedoch ein Programm für eine einfache Aufgabe entwickeln, ist dies nicht zu berücksichtigen. Wenn Sie jedoch ein Programm entwickeln, um eine Zufallszahl für wertvolle Dinge wie ein Lotterieprogramm oder ein Glücksspiel zu generieren, wird Ihr Programm vom Management abgelehnt, wenn Sie den oben genannten Fall nicht berücksichtigen.

Für diese Art von Menschen ist hier mein Vorschlag:

Generieren Sie eine Zufallszahl mit Math.random(). (Sagen Sie dies 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.

Wenn Sie wissen, wie man eine Zufallszahlentabelle liest, um eine Zufallszahl auszuwählen, wissen Sie, dass der obige Prozess (Multiplizieren mit 1, 10, 100 usw.) nicht gegen den Prozess verstößt, den ich am Anfang erwähnt habe (weil er nur die ändert) Stelle des Dezimalpunktes.)

Studieren Sie das folgende Beispiel und entwickeln Sie es entsprechend Ihren Anforderungen.

Wenn Sie eine Stichprobe [0,9] benötigen, ist der Boden von n * 10 Ihre Antwort, und wenn Sie [0,99] benötigen, ist der Boden von n * 100 Ihre Antwort und so weiter.

Lassen Sie uns nun in Ihre Rolle eintreten:

Sie haben Zahlen in einem bestimmten Bereich abgefragt. (In diesem Fall sind Sie in diesem Bereich voreingenommen. - Wenn Sie eine Zahl aus [1,6] nehmen, indem Sie einen Würfel werfen, werden Sie in [1,6] voreingenommen, aber es ist immer noch ein Zufall, wenn der Würfel unvoreingenommen ist .)

Betrachten Sie also Ihren Bereich ==> [78, 247] Anzahl der Elemente des Bereichs = 247 - 78 + 1 = 170; (da beide Grenzen inklusive sind.

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

Hinweis: In Methode 1 habe ich zuerst ein Array erstellt, das die benötigten Zahlen enthält, und diese dann zufällig in ein anderes Array eingefügt. Generieren Sie in Methode 2 zufällig Zahlen und überprüfen Sie, ob diese in dem von Ihnen benötigten Bereich liegen. Dann legen Sie es in ein Array. Hier habe ich zwei Zufallszahlen generiert und insgesamt verwendet, um die Geschwindigkeit des Programms zu maximieren, indem die Fehlerrate minimiert wurde, mit der eine nützliche Zahl erhalten wurde. Das Hinzufügen generierter Zahlen führt jedoch auch zu einer gewissen Verzerrung. Daher würde ich meine erste Methode empfehlen, um Zufallszahlen innerhalb eines bestimmten Bereichs zu generieren.

Bei beiden Methoden zeigt Ihre Konsole das Ergebnis an. (Drücken Sie in Chrome f12, um die Konsole zu öffnen.)

Versuchen Sie für eine zufällige Ganzzahl mit einem Bereich:

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

Um diese Funktion und Variationen dieser Funktion zu testen, speichern Sie das folgende HTML / JavaScript in einer Datei und öffnen Sie es mit einem Browser. Der Code erzeugt ein Diagramm, das die Verteilung von einer Million Funktionsaufrufen zeigt. Der Code zeichnet auch die Kantenfälle auf. Wenn die Funktion also einen Wert erzeugt, der größer als das Maximum oder kleiner als das Min ist, wissen Sie es.

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

Um eine Zufallszahl zwischen 1 und 6 zu erhalten, gehen Sie zunächst wie folgt vor:

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

Dies multipliziert eine Zufallszahl mit 6 und addiert dann 0,5 dazu. Runden Sie die Zahl als nächstes auf eine positive ganze Zahl, indem Sie Folgendes tun:

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

Dies rundet die Zahl auf die nächste ganze Zahl.

Oder um es verständlicher zu machen, tun Sie Folgendes:

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

Im Allgemeinen lautet der Code für die Verwendung von Variablen:

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

Der Grund für das Entfernen von 0,5 vom Minimalwert liegt darin, dass Sie mit dem Minimalwert allein eine Ganzzahl erhalten können, die um eins über Ihrem Maximalwert liegt. Indem Sie 0,5 vom Minimalwert wegnehmen, verhindern Sie im Wesentlichen, dass der Maximalwert aufgerundet wird.

Ich hoffe, das hilft.

Mit dem folgenden Code können Sie eine Reihe von Zufallszahlen in einem bestimmten Bereich generieren, ohne sie zu wiederholen.

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

Ich weiß, dass diese Frage bereits beantwortet ist, aber meine Antwort könnte jemandem helfen.

Ich habe diese einfache Methode auf W3Schools gefunden:

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

Hoffe das würde jemandem helfen.

Zufällige ganze Zahl zwischen niedrigster und höchster:

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

Nicht die eleganteste Lösung ... aber etwas schnelles.

Folgendes verwende ich, um Zufallszahlen zu generieren.

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

Wir führen aus, high++weil Math.random()eine Zufallszahl zwischen 0 (einschließlich) und 1 (exklusiv) generiert wird. Die ausgeschlossene Zahl bedeutet, dass wir das Hoch um eins erhöhen müssen, bevor wir eine Mathematik ausführen. Wir subtrahieren dann niedrig von hoch, was uns die höchste zu erzeugende Zahl gibt - niedrig, dann + niedrig, um hoch wieder normal zu machen und die niedrigste Zahl mindestens niedrig zu machen. dann geben wir die resultierende Zahl zurück

random(7,3) könnte zurückkehren 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 erstellt ein Array mit einer Zahl von bis zu 3 Ziffern, was maximal 999 entspricht. Dieser Code ist sehr kurz.

Hier ist ein Beispiel für eine Javascript-Funktion, die ohne Verwendung von Math.random () eine Zufallszahl beliebiger Länge generieren kann :

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

Dies ist meine Einstellung zu einer Zufallszahl in einem Bereich, da ich eine Zufallszahl innerhalb eines Bereichs von Basis zu Exponent erhalten wollte. zB base = 10, exponent = 2, ergibt im Idealfall eine Zufallszahl von 0 bis 100 und so weiter.

Wenn es hilft, es zu benutzen, ist es hier:

// 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() ist schnell und für viele Zwecke geeignet, aber nicht geeignet, wenn Sie kryptografisch sichere Werte benötigen (es ist nicht sicher) oder wenn Sie Ganzzahlen aus einer völlig einheitlichen unverzerrten Verteilung benötigen (der in anderen Antworten verwendete Multiplikationsansatz erzeugt bestimmte Werte etwas häufiger als andere).

In solchen Fällen können wir verwenden crypto.getRandomValues() sichere Ganzzahlen generieren und generierte Werte ablehnen, die wir nicht einheitlich dem Zielbereich zuordnen können. Dies ist langsamer, sollte jedoch nur dann von Bedeutung sein, wenn Sie eine extrem große Anzahl von Werten generieren.

Um das Problem der voreingenommenen Verteilung zu klären, betrachten Sie den Fall, in dem wir einen Wert zwischen 1 und 5 generieren möchten, aber einen Zufallszahlengenerator haben, der Werte zwischen 1 und 16 erzeugt (ein 4-Bit-Wert). Wir möchten, dass jedem Ausgabewert die gleiche Anzahl generierter Werte zugeordnet wird, aber 16 wird nicht gleichmäßig durch 5 geteilt: Es verbleibt ein Rest von 1. Wir müssen also 1 der möglichen generierten Werte ablehnen und erst fortfahren, wenn wir erhalten einer der 15 kleineren Werte, die einheitlich in unseren Zielbereich abgebildet werden können. Unser Verhalten könnte wie folgt aussehen: Pseudocode:

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.

Der folgende Code verwendet eine ähnliche Logik, generiert jedoch stattdessen eine 32-Bit-Ganzzahl, da dies die größte gemeinsame Ganzzahlgröße ist, die durch den Standardtyp von JavaScript dargestellt werden kann number. (Dies kann geändert werden, um BigInts zu verwenden, wenn Sie einen größeren Bereich benötigen.) Unabhängig vom ausgewählten Bereich beträgt der Anteil der abgelehnten generierten Werte immer weniger als 0,5, sodass die erwartete Anzahl der Ablehnungen immer weniger als 1,0 und beträgt normalerweise nahe 0,0; Sie müssen sich keine Sorgen machen, dass es für immer eine Schleife gibt.

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]

Kryptostark

Um Krypto starke zufällige ganze Zahl in Ragne [x, y] try

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

console.log(cs(4,8))

Sie können Sie dieses Code-Snippet,

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 hat eine großartige Antwort geschrieben, aber sie war etwas zu komplex, als dass ich sie hätte begreifen können. Daher fand ich unter https://teamtreehouse.com/community/mathfloor-mathrandom-max-min-1-min-explanation von Jason Anello eine noch einfachere Erklärung derselben Konzepte .

HINWEIS: Das einzig Wichtige, was Sie wissen sollten, bevor Sie Jasons Erklärung lesen, ist die Definition von "Abschneiden". Er benutzt diesen Begriff bei der Beschreibung Math.floor(). Das Oxford-Wörterbuch definiert "abschneiden" als:

Kürzen Sie (etwas), indem Sie die Oberseite oder das Ende abschneiden.

Dies kann die Erzeugung von bis zu 20-stelligen EINZIGARTIGEN Zufallszahlen verarbeiten

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

/ * Eine Funktion namens randUpToaufrufen, die eine Zahl akzeptiert und eine zufällige ganze Zahl zwischen 0 und dieser Zahl zurückgibt? * /

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

/ * Schreibe eine Funktion namens randBetween, die zwei Zahlen akzeptiert, die einen Bereich darstellen, und eine zufällige ganze Zahl zwischen diesen beiden Zahlen zurückgibt. * /

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

/ * Schreibe eine aufgerufene Funktion randFromTill, die zwei Zahlen akzeptiert, die einen Bereich darstellen, und eine Zufallszahl zwischen min (einschließlich) und max (exklusiv) zurückgibt. * /

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

/ * Schreibe eine aufgerufene Funktion randFromTo, die zwei Zahlen akzeptiert, die einen Bereich darstellen, und eine zufällige Ganzzahl zwischen min (einschließlich) und max (einschließlich) zurückgibt * /

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

Ich habe diese Funktion erstellt, die Optionen wie min, max, exclude (eine Liste der auszuschließenden Ints) und seed (falls Sie einen gesetzten Zufallsgenerator wünschen) berücksichtigt.

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
}

Es kann verwendet werden wie:

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

Oder einfacher:

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

Dann können Sie tun:

let item = some_list[n]

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

• random (min, max) erzeugt eine Zufallszahl zwischen min (einschließlich) und max (exklusiv)

• Math.floor rundet eine Zahl auf die nächste Ganzzahl ab

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

Um eine zufällige Ganzzahl zwischen 4 und 8 einschließlich zu generieren, rufen Sie die obige Funktion mit den folgenden Argumenten auf:

generateRandomInteger (4,9)

Meine Methode zur Erzeugung einer Zufallszahl zwischen 0 und n, wobei n <= 10 (n ausgeschlossen):

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