HOWTO · JavaScript
Verwenden Sie einen Seed, um Zufallszahlen in JavaScript zu generieren
Dieser Artikel befasst sich mit der Verwendung eines Seeds zum Generieren einer Zufallszahl in JavaScript. Wir erreichen dies dank PRNGs, die einen Seed nehmen und basierend auf diesem Seed eine Zufallszahl zurückgeben.
Auf dieser Seite
Um in JavaScript reproduzierbare Pseudozufallszahlen zu erzeugen, initialisieren Sie einen Generator mit einem Seed und verwenden Sie jedes Mal denselben Seed, dieselbe Generatorimplementierung und dieselbe Aufrufreihenfolge. Math.random() akzeptiert keinen Seed. Verwenden Sie daher einen Generator mit Seed, etwa eines der folgenden Beispiele oder seedrandom.js.
So funktioniert Zufall mit Seed
JavaScripts Math.random() akzeptiert keinen Seed. Um eine Zahlenfolge zu reproduzieren, erstellen Sie einen Pseudozufallszahlengenerator (PRNG), der einen Anfangszustand entgegennimmt. Wird dieser Generator mit demselben Seed, derselben Implementierung und derselben Folge von Aufrufen verwendet, erzeugt er dieselbe Zahlenfolge. Wird einer dieser Eingabewerte geändert, können sich spätere Werte unterscheiden.
Ein Seed initialisiert einen Generator; er ist selbst keine Zufallszahl. Trennen Sie die Umwandlung einer benutzerfreundlichen Eingabe wie einer Zeichenfolge vom Algorithmus, der den Generatorzustand fortschreibt. Die folgenden Beispiele verwenden kleine, vielseitige PRNGs für reproduzierbare Simulationen, Demos und Tests.
Eine Zeichenfolge in Generator-Seeds umwandeln
SFC32 und Xoshiro128** verwenden vier 32-Bit-Zustandswerte. Eine Zeichenfolge muss daher vor der Initialisierung dieser Generatoren in vier Zahlenwerte umgewandelt werden. Dieser kompakte Hash ist eine Möglichkeit dafür. Er ist kein kryptografischer Hash und sollte nicht zum Schutz von Geheimnissen verwendet werden. Wie bei jedem Hash fester Breite können verschiedene Zeichenfolgen denselben Wert ergeben.
Die Funktion mischt jede UTF-16-Codeeinheit in vier vorzeichenlose 32-Bit-Werte. Ihre Ausgabe eignet sich als deterministischer Beispielzustand, fügt jedoch keine Entropie hinzu und macht den Generator nicht sicher. Verwenden Sie dieselbe Zeichenfolge und dieselbe Funktion, wenn Sie denselben Anfangszustand wiederherstellen möchten.
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
function hashStringToWords(string) {
let a = 0x9e3779b9;
let b = 0x243f6a88;
let c = 0xb7e15162;
let d = 0xdeadbeef;
for (let i = 0; i < string.length; i++) {
const k = string.charCodeAt(i);
a = Math.imul(a ^ k, 0x85ebca6b);
b = Math.imul(b ^ k, 0xc2b2ae35);
c = Math.imul(c ^ k, 0x27d4eb2f);
d = Math.imul(d ^ k, 0x165667b1);
a ^= b >>> 13;
b ^= c >>> 11;
c ^= d >>> 15;
d ^= a >>> 9;
}
return [a, b, c, d].map((word) => word >>> 0);
}
const words = hashStringToWords("demo seed");
console.log(words.join(", "));
Ein Generator muss außerdem passend zu seinen Zustandsanforderungen initialisiert werden. SFC32 und Xoshiro128** benötigen jeweils vier Werte; Mulberry32 benötigt eine 32-Bit-Zahl. Das folgende Beispiel für JSF erweitert einen Wert zu vier Anfangswerten und wärmt den Zustand auf, bevor es Werte zurückgibt. Übergeben Sie nicht einfach viermal denselben Einzelwert und nehmen Sie an, dass jeder Generator damit korrekt initialisiert wird.
Zahlen mit SFC32, Mulberry32, Xoshiro128** und JSF erzeugen
Diese Funktionen geben Werte im Intervall von 0 (einschließlich) bis 1 (ausschließlich) zurück. SFC32 und Xoshiro128** erhalten die vier Werte von hashStringToWords; Mulberry32 und JSF verwenden den ersten Wert. Jede Funktion hält veränderlichen Zustand fest. Erstellen Sie deshalb einen neuen Generator, um seine Zahlenfolge neu zu beginnen.
SFC32 aktualisiert bei jedem Aufruf vier 32-Bit-Werte, auch wenn der Anfangszustand ausschließlich aus Nullen besteht. Xoshiro128** erfordert einen Zustand ungleich null; der Hash-Helfer liefert für die gezeigte Eingabe demo seed vier von null verschiedene Werte.
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
function hashStringToWords(string) {
let a = 0x9e3779b9;
let b = 0x243f6a88;
let c = 0xb7e15162;
let d = 0xdeadbeef;
for (let i = 0; i < string.length; i++) {
const k = string.charCodeAt(i);
a = Math.imul(a ^ k, 0x85ebca6b);
b = Math.imul(b ^ k, 0xc2b2ae35);
c = Math.imul(c ^ k, 0x27d4eb2f);
d = Math.imul(d ^ k, 0x165667b1);
a ^= b >>> 13; b ^= c >>> 11; c ^= d >>> 15; d ^= a >>> 9;
}
return [a, b, c, d].map((word) => word >>> 0);
}
function sfc32(a, b, c, d) {
return function () {
a >>>= 0; b >>>= 0; c >>>= 0; d >>>= 0;
let t = (a + b) | 0;
a = b ^ (b >>> 9);
b = (c + (c << 3)) | 0;
c = (c << 21) | (c >>> 11);
d = (d + 1) | 0;
t = (t + d) | 0;
c = (c + t) | 0;
return (t >>> 0) / 4294967296;
};
}
const random = sfc32(...hashStringToWords("demo seed"));
console.log(random());
console.log(random());
Mulberry32 ist ein kompakter Generator mit einem Zustandswert. Durch die Addition einer festen Konstante wird sein Zustand fortgeschrieben, bevor die Bits für jedes Ergebnis gemischt werden.
function mulberry32(seed) {
let state = seed >>> 0;
return function () {
let t = (state += 0x6d2b79f5);
t = Math.imul(t ^ (t >>> 15), t | 1);
t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
};
}
function hashStringToWords(string) {
let a = 0x9e3779b9;
for (let i = 0; i < string.length; i++) {
a = Math.imul(a ^ string.charCodeAt(i), 0x85ebca6b);
a ^= a >>> 13;
}
return a >>> 0;
}
const random = mulberry32(hashStringToWords("demo seed"));
for (let i = 0; i < 5; i++) console.log(random());
Xoshiro128** verwendet vier Werte und eine Stern-Stern-Ausgabetransformation. Der Zustandsübergang ist von der Berechnung der Ausgabe getrennt. Bewahren Sie daher alle vier aktualisierten Werte zwischen den Aufrufen auf.
function xoshiro128ss(s) {
s = s.map((word) => word >>> 0);
return function () {
const result = Math.imul(((Math.imul(s[1], 5) << 7) |
(Math.imul(s[1], 5) >>> 25)), 9) >>> 0;
const t = s[1] << 9;
s[2] ^= s[0];
s[3] ^= s[1];
s[1] ^= s[2];
s[0] ^= s[3];
s[2] ^= t;
s[3] = (s[3] << 11) | (s[3] >>> 21);
return result / 4294967296;
};
}
function hashStringToWords(string) {
let a = 0x9e3779b9, b = 0x243f6a88, c = 0xb7e15162, d = 0xdeadbeef;
for (let i = 0; i < string.length; i++) {
const k = string.charCodeAt(i);
a = Math.imul(a ^ k, 0x85ebca6b); b = Math.imul(b ^ k, 0xc2b2ae35);
c = Math.imul(c ^ k, 0x27d4eb2f); d = Math.imul(d ^ k, 0x165667b1);
a ^= b >>> 13; b ^= c >>> 11; c ^= d >>> 15; d ^= a >>> 9;
}
return [a, b, c, d].map((word) => word >>> 0);
}
const random = xoshiro128ss(hashStringToWords("demo seed"));
console.log(random());
Auch JSF (Jenkins Small Fast) verwendet vier Zustandswerte. Diese Variante leitet den Anfangszustand aus dem ersten Hash-Wert ab, führt vor der Ausgabe 20 Zustandsübergänge aus und skaliert anschließend ein 32-Bit-Ergebnis auf dasselbe Intervall.
function jsf32(seed) {
let a = 0xf1ea5eed;
let b = seed >>> 0;
let c = seed >>> 0;
let d = seed >>> 0;
function nextUint32() {
const e = (a - ((b << 27) | (b >>> 5))) | 0;
a = b ^ ((c << 17) | (c >>> 15));
b = (c + d) | 0;
c = (d + e) | 0;
d = (a + e) | 0;
return d >>> 0;
}
for (let i = 0; i < 20; i++) nextUint32();
return () => nextUint32() / 4294967296;
}
function hashStringToWord(string) {
let a = 0x9e3779b9;
for (let i = 0; i < string.length; i++) {
a = Math.imul(a ^ string.charCodeAt(i), 0x85ebca6b);
a ^= a >>> 13;
}
return a >>> 0;
}
const random = jsf32(hashStringToWord("demo seed"));
for (let i = 0; i < 3; i++) console.log(random());
Die Algorithmen erzeugen selbst dann unterschiedliche Zahlenfolgen, wenn sie mit derselben Zeichenfolge initialisiert werden, denn ihre Zustandsübergänge unterscheiden sich. Für reproduzierbare Ergebnisse müssen neben dem Seed auch der Algorithmus und die Aufrufreihenfolge gleich bleiben.
seedrandom.js verwenden
seedrandom.js ist eine JavaScript-Bibliothek zur Erzeugung von Pseudozufallszahlen mit Seed. Der folgende Quelltext für eine Browserseite lädt Version 3.0.5 von CDNJS, erstellt mit der Zeichenfolge Johnson einen Generator und gibt dessen ersten Wert in der Konsole aus. Zum Laden des Skripts benötigt der Browser eine Netzwerkverbindung. Der Quelltext ist zum Anpassen gedacht; die Ausgabe wurde hier nicht zur Laufzeit überprüft.
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
<body>
<script src="https://cdnjs.cloudflare.com/ajax/libs/seedrandom/3.0.5/seedrandom.min.js"></script>
<script>
const random = new Math.seedrandom("Johnson");
console.log(random());
</script>
</body>
Eine Generatorinstanz stellt außerdem die Methoden quick() und int32() bereit. quick() gibt einen Bruchwert zurück; int32() liefert eine vorzeichenbehaftete 32-Bit-Ganzzahl. Jeder Aufruf schreitet im Generatorzustand weiter. Der zweite Aufruf entspricht daher einer anderen Stelle in der Zahlenfolge als der erste.
<body>
<script src="https://cdnjs.cloudflare.com/ajax/libs/seedrandom/3.0.5/seedrandom.min.js"></script>
<script>
const random = new Math.seedrandom("DavidBau");
console.log("With quick():", random.quick());
console.log("With int32():", random.int32());
</script>
</body>
Verhalten mit Seed, Entropie oder automatischer Initialisierung wählen
Verwenden Sie einen expliziten Seed, wenn Sie eine Zahlenfolge mit derselben Eingabe reproduzieren möchten. Das bereitgestellte Beispiel für seedrandom.js zeigt neben einem Seed auch die Option { entropy: true }. Es veranschaulicht, dass diese Option übergeben wird, belegt jedoch weder eine bestimmte Entropiequelle noch eine Garantie oder eine Eigenschaft der Reproduzierbarkeit. Verlassen Sie sich daher nicht auf solche Aussagen.
Der Code und die angezeigten Bezeichnungen oder Ausgaben in diesem Abschnitt bleiben auf Englisch.
<body>
<script src="https://cdnjs.cloudflare.com/ajax/libs/seedrandom/3.0.5/seedrandom.min.js"></script>
<script>
const random = new Math.seedrandom("Antananarivo", { entropy: true });
for (let i = 0; i < 5; i++) console.log(random());
</script>
</body>
Wenn Sie neue Werte statt einer reproduzierbaren Demo benötigen, wählen Sie eine dafür geeignete Quelle und beachten Sie deren dokumentiertes Verhalten. Dieser Artikel macht keine Annahmen über weggelassene Seed-Argumente oder Optionen, die über die oben gezeigten Aufrufe hinausgehen.
Grenzen von Pseudozufallszahlen mit Seed
PRNGs mit Seed sind nützlich, wenn ein Programm reproduzierbare Zahlenfolgen benötigt, etwa für eine Simulation oder eine deterministische Testvorrichtung. Sie sind Algorithmen und keine Quellen für unvorhersehbare Geheimnisse. Ist der Seed vorhersehbar, ist es auch die daraus erzeugte Zahlenfolge; ein selbst erstellter String-Hash ändert daran nichts.
Verwenden Sie diese Beispiele nicht, um Passwörter, Authentifizierungstoken, kryptografische Schlüssel oder andere sicherheitsrelevante Werte zu erzeugen. Nutzen Sie dafür eine kryptografisch sichere Zufalls-API, die zur Laufzeitumgebung und Plattform passt. Gehen Sie außerdem nicht davon aus, dass zwei unterschiedliche PRNG-Implementierungen allein aufgrund desselben Seeds übereinstimmen: Behalten Sie den Algorithmus, die Seed-Umwandlung, den Anfangszustand sowie Anzahl und Reihenfolge der Aufrufe bei.