Gibt es eine Möglichkeit, eine Zufallszahl in einem bestimmten Bereich (z. B. von 1 bis 6: 1, 2, 3, 4, 5 oder 6) in JavaScript zu generieren?

Wichtig

Der folgende Code funktioniert nur, wenn der Mindestwert ist 1. Es funktioniert nicht für andere Mindestwerte als 1.

Wenn Sie eine zufällige Ganzzahl zwischen 1 ( und nur 1 ) und 6 erhalten möchten, würden Sie Folgendes berechnen:

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

Wo:

• 1 ist die Startnummer
• 6 ist die Anzahl der möglichen Ergebnisse (1 + Start (6) - Ende (1) )

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

Was es "extra" macht, ist, dass es zufällige Intervalle zulässt, die nicht mit 1 beginnen. So können Sie beispielsweise eine Zufallszahl von 10 bis 15 erhalten. Flexibilität.

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.

Andere Lösungen:

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

Versuchen Sie es online

TL; DR

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

Um die Zufallszahl zu erhalten generateRandomInteger(-20, 20);

ERKLÄRUNG UNTEN

Wir müssen eine zufällige ganze Zahl erhalten, sagen wir X zwischen min und max.

Recht?

dh min <= X <= max

Wenn wir min von der Gleichung subtrahieren, ist dies äquivalent zu

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

Multiplizieren wir dies nun mit einer Zufallszahl r, die ist

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

Fügen wir nun min wieder zur Gleichung hinzu

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

Wählen wir nun eine Funktion, die zu r führt, so dass sie unseren Gleichungsbereich als [min, max] erfüllt. Dies ist nur möglich, wenn 0 <= r <= 1

OK. Der Bereich von r ie [0,1] ist dem Ergebnis der Math.random () -Funktion sehr ähnlich. Ist es nicht?

Die Funktion Math.random () gibt eine Gleitkomma-Pseudozufallszahl im Bereich [0, 1) zurück. das heißt, von 0 (einschließlich) bis einschließlich 1 (exklusiv)

Zum Beispiel,

Fall r = 0

min+ 0 * ( max- min) = min

Fall r = 1

min+ 1 * ( max- min) = max

Zufälliger Fall mit Math.random 0 <= r <1

min+ r * ( max- min) = X , wobei X einen Bereich von min <= X < max hat

Das obige Ergebnis X ist eine Zufallszahl. Aufgrund von Math.random () ist unsere linke Grenze jedoch inklusive und die rechte Grenze ist exklusiv. Um unsere rechte Grenze einzuschließen, erhöhen wir die rechte Grenze um 1 und begründen das Ergebnis.

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

Um die Zufallszahl zu erhalten

generateRandomInteger(-20, 20);;

Oder in Unterstrich

_.random(min, max)

var x = 6; // can be any number
var rand = Math.floor(Math.random()*x) + 1;

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

Random Integer : Um eine zufällige Ganzzahl zwischen minund zu erhalten max, verwenden Sie den folgenden Code

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

Zufällige Gleitkommazahl : Um eine zufällige Gleitkommazahl zwischen minund zu erhalten max, verwenden Sie den folgenden Code

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

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

Mathematik ist nicht meine Stärke, aber ich habe an einem Projekt gearbeitet, bei dem ich viele Zufallszahlen zwischen positiv und negativ generieren musste.

function randomBetween(min, max) {
    if (min < 0) {
        return min + Math.random() * (Math.abs(min)+max);
    }else {
        return min + Math.random() * max;
    }
}

Z.B

randomBetween(-10,15)//or..
randomBetween(10,20)//or...
randomBetween(-200,-100)

Natürlich können Sie auch eine Validierung hinzufügen, um sicherzustellen, dass Sie dies nur mit Zahlen tun. Stellen Sie außerdem sicher, dass min immer kleiner oder gleich max ist.

Ich habe eine flexiblere Funktion geschrieben, die Ihnen Zufallszahlen geben kann, aber nicht nur Ganzzahlen.

function rand(min,max,interval)
{
    if (typeof(interval)==='undefined') interval = 1;
    var r = Math.floor(Math.random()*(max-min+interval)/interval);
    return r*interval+min;
}

var a = rand(0,10); //can be 0, 1, 2 (...) 9, 10
var b = rand(4,6,0.1); //can be 4.0, 4.1, 4.2 (...) 5.9, 6.0

Feste Version.

Beispiel

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

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

Das Ergebnis könnte sein: 3

Versuchen Sie es selbst: hier

- -

oder mit lodash / undescore:

_.random(min, max)

Docs: - lodash - undescore

Trotz vieler Antworten und fast gleichem Ergebnis. Ich möchte meine Antwort hinzufügen und ihre Funktionsweise erklären. Weil es wichtig ist, die Funktionsweise zu verstehen, anstatt das Einfügen eines Zeilencodes zu kopieren. Das Generieren von Zufallszahlen ist nichts anderes als einfache Mathematik.

CODE:

function getR(lower, upper) {

  var percent = (Math.random() * 100);
  // this will return number between 0-99 because Math.random returns decimal number from 0-0.9929292 something like that
  //now you have a percentage, use it find out the number between your INTERVAL :upper-lower 
  var num = ((percent * (upper - lower) / 100));
  //num will now have a number that falls in your INTERVAL simple maths
  num += lower;
  //add lower to make it fall in your INTERVAL
  //but num is still in decimal
  //use Math.floor>downward to its nearest integer you won't get upper value ever
  //use Math.ceil>upward to its nearest integer upper value is possible
  //Math.round>to its nearest integer 2.4>2 2.5>3   both lower and upper value possible
  console.log(Math.floor(num), Math.ceil(num), Math.round(num));
}

Ich habe nach einem in TypeScript geschriebenen Zufallszahlengenerator gesucht und dies nach dem Lesen aller Antworten geschrieben. Ich hoffe, es würde für TypeScript-Codierer funktionieren.

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

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

Hinzufügen floatmit einer Version mit fester Genauigkeit basierend auf der intVersion in der Antwort von @ Francisc:

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

damit:

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

und für int Antwort

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

Kryptostarke zufällige Ganzzahl im Bereich [a, b] (Annahme: a <b)

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

console.log( rand(1,6) );

Das sollte funktionieren:

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

Ich habe eine großartige neue Möglichkeit entdeckt, dies mit ES6-Standardparametern zu tun. Es ist sehr geschickt, da es entweder ein Argument oder zwei Argumente zulässt. Hier ist es:

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

Dies ist ungefähr neun Jahre zu spät, aber randojs.com macht dies zu einem einfachen Einzeiler :

rando(1, 6)

Sie müssen dies nur zum Kopf Ihres HTML-Dokuments hinzufügen, und Sie können so ziemlich alles, was Sie wollen, mit Zufälligkeit leicht tun. Zufällige Werte von Arrays, zufällige Abfrageelemente, zufällige Eigenschaften von Objekten und sogar das Verhindern von Wiederholungen, falls erforderlich.

<script src="https://randojs.com/1.0.0.js"></script>

Dies funktioniert für mich und erzeugt Werte wie die Standardbibliotheksfunktion random.randint von Python :

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

console.log("Random integer: " + randint(-5, 5));

Versuchen Sie es mit:

function random(min, max) {
   return Math.round((Math.random() *( Math.abs(max - min))) + min);
}
console.log(random(1, 6));

1-6 wie ein Würfel im Grunde zurückgeben,

return Math.round(Math.random() * 5 + 1);