Zufällige ganze Zahlen in JavaScript in einem bestimmten Bereich generieren?

1955

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?

zacharyliu
quelle
1
Hier ist eine nützliche Zusammenfassung: gist.github.com/kerimdzhanov/7529623
Dan KK
9
Als Randnotiz: Für diejenigen, die npm verwenden und nach einer schnellen, zuverlässigen und vorgefertigten Lösung suchen , gibt es lodash.random , das bei sehr geringem Platzbedarf leicht benötigt werden kann (es wird nur die Methode selbst und nicht die gesamte lodash importiert).
Nobita
wenn es kryptosicher sein muss developer.mozilla.org/en-US/docs/Web/API/RandomSource/…
glücklich

Antworten:

3834

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 .

Ionuț G. Stan
quelle
10
Das macht es nur, weil es ruft floor, was abrundet.
Josh Stodola
4
@ thezachperson31 Du könntest roundaber beides benutzen minund hatte maxnur die halbe Chance zu würfeln wie die anderen Zahlen. Sie könnten auch eine subtrahieren und nehmen ceil. Dies lässt jedoch die maxZahl aufgrund des [0,1)Intervalls mit einer minimal geringeren Wahrscheinlichkeit zu würfeln .
Christoph
12
Ich habe eine JSFiddle erstellt, wenn jemand die Verteilung dieser Methode testen möchte: jsfiddle.net/F9UTG/1
ahren
8
@ JackFrost ja, das stimmt. Du bist nicht dumm, du lernst nur :)
Ionuț G. Stan
3
Diese Frage ist alt, aber das Verstehen dieser Antwort hat mich viel zu viel Zeit gekostet. Oo, ich denke, die Erweiterung von math.random auf die nächste JavaScript-Version wäre irgendwie nützlich
Jonathan Ortega
527
var randomnumber = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
Darin Dimitrov
quelle
19
Ich weiß, dass dies eine SEHR alte Antwort ist, aber die Verwendung (Math.random() * (maximum - minimum + 1) ) << 0ist schneller.
Ismael Miguel
11
@IsmaelMiguel Binäre Operatoren ( x << 0, x | 0, ~~x) anstelle von Math.floor()Konvertiten xin eine zwei Ergänzung mit vielen kleineren Bereich als Number.MAX_SAFE_INTEGER(2³²⁻¹ vs. 2⁵³), so müssen Sie es mit Vorsicht verwenden!
le_m
@IsmaelMiguel Yo Ich habe gerade deine Methode in der Konsole ausprobiert und zufällig einen negativen Wert erhalten! Math.randRange = (Minimum, Maximum) => (Math.random () * (Maximum - Minimum + 1)) << 0 Math.randRange (2,657348096152) -1407373159
Bluejayke
@bluejayke Weil 657348096152 (1001100100001100111111111111000010011000 in binär) 40 Bit hat, während bitweise Arithmetik 32 Bit verwendet. Wenn Sie dies tun, erhalten 657348096152|0Sie 218099864 (11001111111111000010011000 in binär).
Ismael Miguel
1
Dies ist eine kluge Antwort. Wenn Sie den Bereich intern einstellen [min, max + 1), wird tatsächlich das gewünschte Ergebnis erzielt, wenn [min, max] beide inklusive sind. Vielen Dank! :)
Mladen B.
135

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.

Lior Elrom
quelle
56
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 .

Gordon Gustafson
quelle
1
Mir ist klar, dass dies ungefähr 2½ Jahre später ist, aber mit den Eingaben 1 und 6 gibt Ihre Funktion die Werte 1,2,3,4 und 5 zurück, aber niemals eine 6, als wäre es "inklusive".
einige
9
@some, es könnte schlimmer sein, ich bin 2½ Jahre + 1 Tag später ^^
ajax333221
+1, ich habe Ihren Code getestet, er scheint einen korrekten Wert zu erstellen. Kreative Struktur zur Behandlung fester Szenarien, die im Code häufig wiederholt werden.
Chris
Warum haben Sie dafür eine Funktion innerhalb einer Funktion?
Alph.Dev
1
@ Alph.Dev Zum Entkoppeln der Logik, die den Zufallszahlengenerator verwendet, von der Logik, die genau entscheidet, welche Zufallszahlenverteilung verwendet werden soll. Wenn der Code, der den Zufallszahlengenerator verwendet, ihn als Parameter akzeptiert (eine 0-Argument-Funktion, die immer eine neue Zufallszahl zurückgibt), kann er mit jeder Art von Zufallszahlengenerator arbeiten.
Gordon Gustafson
31
function randomRange(min, max) {
  return ~~(Math.random() * (max - min + 1)) + min
}

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

_.random(min, max)
Codler
quelle
1
Der Unterstrich bietet tatsächlich eine _.uniqueId()Funktion, die Sie für clientseitige Modelle aufrufen können.
obfk
Binäre Operatoren ( x << 0, x | 0, ~~x) anstelle von Math.floor()Konvertiten xin eine zwei Ergänzung mit viel kleineren Bereich als Number.MAX_SAFE_INTEGER(2³²⁻¹ vs. 2⁵³), so haben Sie es verwenden , um mit Vorsicht!
le_m
31

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)
Prasobh.Kollattu
quelle
ist dein "zwischen" inklusive oder exklusiv? dh ist es [1,10], [1,10), (1,10] oder (1,10)?
evandrix
1
Es ist teilweise inklusive: [1, *)
Ivan Z
Was braucht + 1 am Ende der Funktion? Es funktioniert perfekt, denke ich.
Shachi
18

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

Math.floor(Math.random() *  max);
Stanislav Vincent
quelle
Ist max inklusive oder exklusiv>?
Baum
2
@Tree mit Math.floor max ist exklusiv. Wenn Sie möchten, dass max inklusive ist, können Sie Math.round verwenden.
Luke
14

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
Starkers
quelle
1
Ihre Antwort ist wahr, aber ich denke, Ihr Beispiel ist falsch. console.log(randomNumber(5,6)); # 9 6 6 5 7 7Kommen 9 & 7 zwischen 5 & 6? ...... du solltest es korrigieren oder erklären ..
Sachin
12

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
Schöner Islam
quelle
Die MS DotNet Random-Klasse steht unter der Ms-RSL- Lizenz, was bedeutet, dass sie urheberrechtlich geschützt ist. Seien Sie also vorsichtig, wenn Sie diesen abgeleiteten Code verwenden, da er Grund für Fälle von Urheberrechtsverletzungen sein kann.
JohannesB
12

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

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

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

Janaka R Rajapaksha
quelle
3
"zufällig" bedeutet nicht unbedingt "gleichmäßig verteilt". "voreingenommen" bedeutet nicht "nicht zufällig". Zufallsmittel aus einer Wahrscheinlichkeitsverteilung.
Syzygy
6
Kann kaum sagen, was diese Antwort zu sagen versucht. Wenn Sie jedoch Zufallszahlen für Verwendungszwecke wie Lotterienummern und Glücksspiele benötigen. Zuerst sollten Sie sie wahrscheinlich nicht auf dem Client generieren. Zweitens benötigen Sie einen kryptografisch sicheren Zufallszahlengenerator, und das mitgelieferte Algo reicht nicht aus. Wiederholtes zufälliges Aufrufen macht das Ergebnis nicht "zufälliger". Der Autor scheint besorgt über Voreingenommenheit zu sein, bietet aber keine gute Möglichkeit, dies zu verhindern. Tatsächlich erzeugen die anderen kurzen Antworten unverzerrte Zufallszahlen (vorausgesetzt, der zugrunde liegende Zufallsgenerator ist unverzerrt).
Jeff Walker Code Ranger
@ JeffWalkerCodeRanger Ich denke, er meinte damit, dass mit dem "normalen" Algorithmus [dh Math.floor(Math.random() * (6 - 1 + 1) + 1)] die Zahlen 1 und 6 notwendigerweise weniger oft als 2, 3, 4 und 5 gewürfelt werden. Der Unterschied ist jedoch grundsätzlich unbedeutend.
Oldboy
10

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;
}
user1764199
quelle
8
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>
Chris
quelle
7

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.

Learner.js
quelle
Wenn Sie 0 ausschließen , ist es sinnvoll , den Bereich von 0 bis 0,5 nicht abzurunden.
ILMostro_7
7

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

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.

Nussknacker
quelle
1
Math.floor ((Math.random () * 1) + 0); gibt immer 0
madprops
1
@madprops Da die maximale Anzahl exklusiv ist. Um 0 oder 1 zu erhalten, sollten Sie 2 als maximale Anzahl festlegen.
NutCracker
1
oder Sie fügen einfach + 1 in der Funktion hinzu, die diese Methode aufruft
Pietro Coelho
6

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.

Brooklynsweb
quelle
5

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

Travis
quelle
2
Da dies highnur einmal verwendet wird, können Sie auch high-low+1die separate Inkrement-Anweisung verwenden, anstatt sie zu verwenden. Außerdem würden die meisten Benutzer erwarten, dass der lowParameter an erster Stelle steht.
Chris Walsh
4
    <!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.

glücklich
quelle
4

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;
    }
Nilesh Pawar
quelle
t1 / t2 immer sehr nahe an 1. und daher gibt Ihre Funktion dieselbe Nummer zurück, wenn die Funktion wiederholt aufgerufen wird. jsbin.com/xogufacera/edit?js,console
Sunil BN
Überprüfen Sie die jsbin URL .. Sie werden die Ausgabe selbst sehen
Sunil BN
Es funktioniert hervorragend, wenn die Länge zwischen 4 und 10 liegt (wie ich auf meinem Computer getestet habe), da die Werte der Konstanten T1 und T2 einen angemessenen Abstand haben sollten.
Nilesh Pawar
3

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);
Goran B.
quelle
3

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]

Jeremy Banks
quelle
3

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

Kamil Kiełczewski
quelle
4
Dieser ist faszinierend
Akin Hwan
1

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;
}
Achintha Isuru
quelle
1
Hier gibt es eine unnötige doppelte Zeile. Verwenden Sie einfach do - whileanstelle vonwhile
Javi Marzán
1

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.

Dani Amsalem
quelle
0

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

Geben Sie hier die Bildbeschreibung ein

JsFiddle

Nofi
quelle
Ich stimme dem nur deshalb zu.
Taylor Ackley
1
@ TaylorAckley Diese Antwort geht nicht auf die Frage ein.
RomainValeri
0

/ * 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;
};
Prakhar Mittal
quelle
1
Schön, könnten Sie auch feststellen, dass randBetween (exklusiv) (exklusiv) ist?
Pfdint
0

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

Madprops
quelle
0
  • 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)
Normajean
quelle
0

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

Math.floor((Math.random() * 10) % n)
Nitin Jadhav
quelle