Generieren Sie in JavaScript eine Zufallszahl zwischen zwei Zahlen

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

"Extra" ist, dass es zufällige Intervalle erlaubt, die nicht mit 1 ..__ beginnen. So können Sie beispielsweise eine Zufallszahl von 10 bis 15 erhalten. Flexibilität.

Math.random ()

Aus der Mozilla Developer Network-Dokumentation:

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

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

Nützliche Beispiele:

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

Andere Lösungen:

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

TL; DR

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

So erhalten Sie die Zufallszahl generateRandomInteger(-20, 20);

ERKLÄRUNG UNTEN

Wir brauchen eine zufällige Ganzzahl, sagen wir [~ # ~] x [~ # ~] zwischen min und max.

Richtig?

d.h. min <= X <= max

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

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

Multiplizieren wir dies nun mit einer Zufallszahl r

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

Addieren wir nun min zur Gleichung

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

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

OKAY. Nun ist der Bereich von r d. H. [0,1] dem Ergebnis der Math.random () -Funktion sehr ähnlich. Ist es nicht

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

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

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 untermauern das Ergebnis.

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

Um die Zufallszahl zu erhalten

generateRandomInteger(-20, 20);

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

Random Integer: Um eine zufällige Ganzzahl zwischen min und max zu erhalten, 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;
}

Random Floating Point Number: Um eine zufällige Gleitkommazahl zwischen min und max zu erhalten, 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

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

Oder in Unterstrich

_.random(min, max)

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 Bestätigung hinzufügen, um sicherzustellen, dass Sie dies nicht mit anderen Zahlen als Zahlen tun. Stellen Sie außerdem sicher, dass min immer kleiner oder gleich max ist.

Ich habe eine flexiblere Funktion geschrieben, die Ihnen eine Zufallszahl geben kann, aber nicht nur eine ganze Zahl.

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

Gib 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/uncore:

_.random(min, max)

Docs: - lodash - ncore

Ich suchte nach einem Zufallszahlengenerator, der in TypeScript geschrieben wurde, und habe dies geschrieben, nachdem ich alle Antworten gelesen hatte.

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

Trotz vieler Antworten und fast gleichem Ergebnis. Ich möchte meine Antwort hinzufügen und ihre Funktionsweise erläutern. Weil es wichtig ist, die Funktionsweise zu verstehen, anstatt das Einfügen eines Zeilencodes zu kopieren. Zufallszahlen zu generieren 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));
}

Es ist sinnvoll, dass Sie zur maximalen Zahl 1 addieren und dann die Mindestanzahl abziehen müssen, damit dies funktioniert, und ich muss viele zufällige Ganzzahlen erstellen. Diese Funktion funktioniert.

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

Dies funktioniert sowohl mit negativen als auch mit positiven Zahlen, und ich arbeite an Dezimalzahlen für eine Bibliothek.

Um eine Zufallszahl in Javascript zu erstellen, können wir das eingebaute Javascript-Objekt Math verwenden. Das Math-Objekt enthält eine Funktion Math.random(). Diese Funktion führt Folgendes aus (Quell-MDN):

Die Funktion Math.random () gibt einen Fließkomma-Pseudozufallswert zurück Zahl im Bereich von 0–1 (einschließlich 0, aber nicht 1) mit ungefähr Gleichmäßige Verteilung über diesen Bereich - den Sie dann auf .__ skalieren können. Ihr gewünschter Bereich.

Mit dieser Funktionalität können wir dies problemlos in komplexere Szenarien skalieren. Zum Beispiel:

function randomNR (x, y){
return Math.round((Math.random() * x + y));
}

// dice >> random number between 1-6
// dice functionality without function >> Math.round((Math.random() * 5 + 1))
console.log(randomNR(5,1));


// coin >> random number between 0-1
// coin functionality without function >> Math.round((Math.random() * 1))
console.log(randomNR(1,0))

Ich habe eine großartige neue Möglichkeit gefunden, dies mit den Standardparametern von ES6 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;
}

Das sollte funktionieren:

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

Hinzufügen von float mit fester Genauigkeit basierend auf der int-Version 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
}

so:

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

und für die int Antwort

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

Math.random() ist schnell und für viele Zwecke geeignet, aber es ist nicht angemessen, wenn Sie kryptografisch sichere Werte benötigen (es ist nicht sicher) oder wenn Sie Ganzzahlen aus einer vollständig gleichmäßigen, unverfälschten Verteilung benötigen (der in anderen Antworten verwendete Multiplikationsansatz liefert bestimmte Werte etwas mehr oft als andere).

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

Betrachten Sie zur Verdeutlichung des Problems der voreingenommenen Verteilung den Fall, in dem ein Wert zwischen 1 und 5 generiert werden soll, ein Zufallszahlengenerator jedoch Werte zwischen 1 und 16 (ein 4-Bit-Wert). Wir möchten, dass jedem Ausgabewert die gleiche Anzahl von generierten Werten zugeordnet wird, aber 16 wird nicht gleichmäßig durch 5 dividiert: Es verbleibt ein Rest von 1. Wir müssen also 1 der möglichen generierten Werte ablehnen und erst dann fortfahren, wenn wir sie erhalten einer der 15 niedrigeren Werte, die einheitlich in unserem Zielbereich abgebildet werden können. Unser Verhalten könnte wie folgt aussehen:

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 vom JavaScript-Standardtyp number dargestellt werden kann. (Dies kann geändert werden, um BigInts zu verwenden, wenn Sie einen größeren Bereich benötigen.) Unabhängig vom ausgewählten Bereich liegt der Anteil der zurückgewiesenen generierten Werte immer unter 0,5, sodass die erwartete Anzahl von Zurückweisungen immer unter 1,0 und liegt normalerweise nahe an 0.0; Sie brauchen sich keine Sorgen zu 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]