BigInt Werte repräsentieren Ganzzahlwerte, diezu hoch oderzu niedrig sind, um durch dennumberPrimitiv dargestellt zu werden.

Beschreibung

EinBigInt Wert, manchmal einfach nurBigInt genannt, ist einbigintPrimitiv, das durch Anhängen vonn an das Ende eines ganzzahligen Literals erstellt wird oder durch Aufrufen derBigInt() Funktion (ohne dennew Operator) unter Angabe eines Ganzzahlen- oder Stringwerts.

const previouslyMaxSafeInteger = 9007199254740991n;const alsoHuge = BigInt(9007199254740991);// 9007199254740991nconst hugeString = BigInt("9007199254740991");// 9007199254740991nconst hugeHex = BigInt("0x1fffffffffffff");// 9007199254740991nconst hugeOctal = BigInt("0o377777777777777777");// 9007199254740991nconst hugeBin = BigInt(  "0b11111111111111111111111111111111111111111111111111111",);// 9007199254740991n

BigInt-Werte sind in einigen Aspekten ähnlich zu Number-Werten, unterscheiden sich jedoch in einigen wichtigen Punkten: Ein BigInt-Wert kann nicht mit Methoden des eingebautenMath Objekts verwendet werden und kann in Operationen nicht mit einem Number-Wert gemischt werden; sie müssen auf denselben Typ gezwungen werden. Seien Sie vorsichtig beim Hin- und Herzwingen von Werten, da die Genauigkeit eines BigInt-Werts verloren gehen kann, wenn er in einen Number-Wert umgewandelt wird.

Typinformationen

Beim Testen mittypeof gibt ein BigInt-Wert (bigint Primitiv)"bigint" zurück:

typeof 1n === "bigint"; // truetypeof BigInt("1") === "bigint"; // true

Ein BigInt-Wert kann auch in einemObject verpackt werden:

typeof Object(1n) === "object"; // true

Operatoren

Die meisten Operatoren unterstützen BigInts, jedoch erlauben die meisten keine Operanden aus gemischten Typen — beide Operanden müssen BigInt sein oder keiner:

• Arithmetische Operatoren:+,-,*,/,%,**
• Bitweise Operatoren:>>,<<,&,|,^,~
• Unäre Negation (-)
• Inkrement/Dekrement:++,--

Die boolean-rückgebenden Operatoren erlauben die Mischung von Zahlen und BigInts als Operanden:

• Relationsoperatoren undGleichheitsoperatoren:>,<,>=,<=,==,!=,===,!==
• Logische Operatoren verlassen sich nur auf dieTruthiness der Operanden

Einige Operatoren unterstützen BigInt überhaupt nicht:

• Unäres Plus (+) kann nicht unterstützt werden aufgrund der widersprüchlichen Nutzung in asm.js und wurde ausgelassenum asm.js nicht zu beschädigen.
• Unsigned Right Shift (>>>) ist der einzige bitweise Operator, der nicht unterstützt wird, da jeder BigInt-Wert ein Vorzeichen hat.

Besondere Fälle:

• Addition (+), die eine Zeichenkette und ein BigInt beinhaltet, gibt eine Zeichenkette zurück.
• Division (/) schneidet gebrochene Komponenten Richtung Null ab, da BigInt nicht in der Lage ist, gebrochene Mengen darzustellen.

const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991nconst maxPlusOne = previousMaxSafe + 1n; // 9007199254740992nconst theFuture = previousMaxSafe + 2n; // 9007199254740993n, this works now!const prod = previousMaxSafe * 2n; // 18014398509481982nconst diff = prod - 10n; // 18014398509481972nconst mod = prod % 10n; // 2nconst bigN = 2n ** 54n; // 18014398509481984nbigN * -1n; // -18014398509481984nconst expected = 4n / 2n; // 2nconst truncated = 5n / 2n; // 2n, not 2.5n

Vergleiche

Ein BigInt-Wert ist nicht strikt gleich einem Number-Wert, aber er ist eslose:

0n === 0; // false0n == 0; // true

Ein Number-Wert und ein BigInt-Wert können wie gewohnt verglichen werden:

1n < 2; // true2n > 1; // true2 > 2; // false2n > 2; // false2n >= 2; // true

BigInt- und Number-Werte können in Arrays gemischt und sortiert werden:

const mixed = [4n, 6, -12n, 10, 4, 0, 0n];// [4n, 6, -12n, 10, 4, 0, 0n]mixed.sort(); // default sorting behavior// [ -12n, 0, 0n, 10, 4n, 4, 6 ]mixed.sort((a, b) => a - b);// won't work since subtraction will not work with mixed types// TypeError: can't convert BigInt value to Number value// sort with an appropriate numeric comparatormixed.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));// [ -12n, 0, 0n, 4n, 4, 6, 10 ]

Beachten Sie, dass Vergleiche mitObject-eingewickelten BigInt-Werten wie mit anderen Objekten agieren und nur Gleichheit anzeigen, wenn derselbe Objektinstanz verglichen wird:

Object(0n) === 0n; // falseObject(0n) === Object(0n); // falseconst o = Object(0n);o === o; // true

Da das Erzwingen zwischen Number-Werten und BigInt-Werten zu einem Verlust der Präzision führen kann, wird folgendes empfohlen:

• Verwenden Sie einen BigInt-Wert nur, wenn Werte größer als 2⁵³ vernünftigerweise erwartet werden.
• Erzwingen Sie nicht zwischen BigInt-Werten und Number-Werten.

Bedingte Anweisungen

Ein BigInt-Wert folgt denselben Konvertierungsregeln wie Numbers, wenn:

• er in einenBoolean konvertiert wird: über dieBoolean Funktion;
• wenn er mitlogischen Operatoren||,&& und! verwendet wird; oder
• innerhalb eines bedingten Tests wie einemif Statement.

Nämlich, nur0n istfalsy; alles andere isttruthy.

if (0n) {  console.log("Hello from the if!");} else {  console.log("Hello from the else!");}// "Hello from the else!"0n || 12n; // 12n0n && 12n; // 0nBoolean(0n); // falseBoolean(12n); // true!12n; // false!0n; // true

Kryptografie

Die auf BigInt-Werten unterstützten Operationen sind nicht konstant der Zeit und somit anfällig fürTiming-Angriffe. JavaScript BigInts könnten daher gefährlich sein, wenn sie ohne Abhilfemaßnahmen in der Kryptografie verwendet werden. Ein sehr generisches Beispiel könnte ein Angreifer die Zeitdifferenz zwischen101n ** 65537n und17n ** 9999n messen und die Größe von Geheimnissen, wie privaten Schlüsseln, basierend auf der verstrichenen Zeit ableiten. Wenn Sie dennoch BigInts verwenden müssen, schauen Sie sich denTiming Attack FAQ für allgemeine Ratschläge zu diesem Thema an.

Verwendung innerhalb von JSON

Die Verwendung vonJSON.stringify() mit einem BigInt-Wert wird einenTypeError auslösen, da BigInt-Werte im JSON standardmäßig nicht serialisiert werden. Allerdings lässtJSON.stringify() speziell eine Hintertür für BigInt-Werte: es versucht, dietoJSON() Methode des BigInt aufzurufen. (Dies geschieht nicht für andere primitive Werte.) Daher können Sie Ihre eigenetoJSON() Methode implementieren (was einer der wenigen Fälle ist, in denen das Patchen von eingebauten Objekten nicht ausdrücklich entmutigt wird):

BigInt.prototype.toJSON = function () {  return { $bigint: this.toString() };};

Anstatt einen Fehler auszulösen, erzeugtJSON.stringify() nun einen String wie diesen:

console.log(JSON.stringify({ a: 1n }));// {"a":{"$bigint":"1"}}

Wenn Sie nichtBigInt.prototype patchen möchten, können Sie denreplacer Parameter vonJSON.stringify verwenden, um BigInt-Werte zu serialisieren:

const replacer = (key, value) =>  typeof value === "bigint" ? { $bigint: value.toString() } : value;const data = {  number: 1,  big: 18014398509481982n,};const stringified = JSON.stringify(data, replacer);console.log(stringified);// {"number":1,"big":{"$bigint":"18014398509481982"}}

Sie können dann denreviver Parameter vonJSON.parse verwenden, um sie zu handhaben:

const reviver = (key, value) =>  value !== null &&  typeof value === "object" &&  "$bigint" in value &&  typeof value.$bigint === "string"    ? BigInt(value.$bigint)    : value;const payload = '{"number":1,"big":{"$bigint":"18014398509481982"}}';const parsed = JSON.parse(payload, reviver);console.log(parsed);// { number: 1, big: 18014398509481982n }

Tatsächlich erlaubt JSON Zahlenliterale, die willkürlich lang sind; sie können nur in JavaScript nicht mit voller Präzision geparst werden. Wenn Sie mit einem anderen Programm in einer Sprache kommunizieren, die längere Ganzzahlen unterstützt (wie 64-Bit-Ganzzahlen), und Sie möchten das BigInt lieber als JSON-Zahl anstatt als JSON-String übertragen, sieheLossless number serialization.

BigInt-Koerzierung

Viele eingebaute Operationen, die BigInts erwarten, zwingen ihre Argumente zuerst zu BigInts.Die Operation kann wie folgt zusammengefasst werden:

• BigInts werden unverändert zurückgegeben.
• undefined undnull werfen einenTypeError.
• true wird zu1n;false wird zu0n.
• Strings werden umgewandelt, indem sie so geparst werden, als ob sie ein Ganzzahlenliteral enthalten. Jeder Parsing-Fehler führt zu einemSyntaxError. Die Syntax ist ein Teilmenge vonNummerische String-Literale, wobei Dezimalpunkte oder Exponenten-Indikatoren nicht erlaubt sind.
• Zahlen werfen einenTypeError, um zu verhindern, dass unbeabsichtigte implizite Koerzierung zu einem Verlust der Genauigkeit führt.
• Symbole werfen einenTypeError.
• Objekte werden zunächstin ein primitives umgewandelt durch Aufrufen ihrer[Symbol.toPrimitive]() (mit"number" als Hinweis),valueOf(), undtoString() Methoden, in dieser Reihenfolge. Das resultierende Primitiv wird dann in ein BigInt umgewandelt.

Der beste Weg, um nahezu denselben Effekt in JavaScript zu erzielen, ist die Verwendung derBigInt() Funktion:BigInt(x) verwendet denselben Algorithmus, umx zu konvertieren, mit der Ausnahme, dassZahlen keinenTypeError werfen, sondern zu BigInts konvertiert werden, wenn sie Ganzzahlen sind.

Beachten Sie, dass eingebaute Operationen, die BigInts erwarten, oft das BigInt nach der Koerzierung auf eine feste Breite kürzen. Dies schließtBigInt.asIntN(),BigInt.asUintN(), und Methoden vonBigInt64Array undBigUint64Array ein.

Konstruktor

BigInt()

Gibt primitive Werte des Typs BigInt zurück. Wirft einen Fehler, wenn er mitnew aufgerufen wird.

Statische Methoden

BigInt.asIntN()

Begrenzt einen BigInt-Wert auf einen vorzeichenbehafteten Ganzzahlenwert und gibt diesen Wert zurück.

BigInt.asUintN()

Begrenzt einen BigInt-Wert auf einen nicht vorzeichenbehafteten Ganzzahlenwert und gibt diesen Wert zurück.

Instanzeigenschaften

Diese Eigenschaften sind inBigInt.prototype definiert und werden von allenBigInt Instanzen geteilt.

BigInt.prototype.constructor

Die Konstruktionsfunktion, die das Instanzobjekt erstellt hat. FürBigInt Instanzen ist der Anfangswert derBigInt Konstruktor.

BigInt.prototype[Symbol.toStringTag]

Der Anfangswert der[Symbol.toStringTag] Eigenschaft ist der String"BigInt". Diese Eigenschaft wird inObject.prototype.toString() verwendet. Da jedochBigInt auch seine eigenetoString() Methode hat, wird diese Eigenschaft nicht verwendet, es sei denn, Sie rufenObject.prototype.toString.call() mit einem BigInt alsthisArg auf.

Instanzmethoden

BigInt.prototype.toLocaleString()

Gibt einen String mit einer sprachabhängigen Darstellung dieses BigInt-Werts zurück. Überschreibt dieObject.prototype.toLocaleString() Methode.

BigInt.prototype.toString()

Gibt einen String zurück, der diesen BigInt-Wert in der angegebenen Basis (Radix) repräsentiert. Überschreibt dieObject.prototype.toString() Methode.

BigInt.prototype.valueOf()

Gibt diesen BigInt-Wert zurück. Überschreibt dieObject.prototype.valueOf() Methode.

Beispiele

Berechnen von Primzahlen

function isPrime(n) {  if (n < 2n) {    return false;  }  if (n % 2n === 0n) {    return n === 2n;  }  for (let factor = 3n; factor * factor <= n; factor += 2n) {    if (n % factor === 0n) {      return false;    }  }  return true;}// Takes a BigInt value as an argument, returns nth prime number as a BigInt valuefunction nthPrime(nth) {  let maybePrime = 2n;  let prime = 0n;  while (nth >= 0n) {    if (isPrime(maybePrime)) {      nth--;      prime = maybePrime;    }    maybePrime++;  }  return prime;}nthPrime(20n);// 73n

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Number
• Number.MAX_SAFE_INTEGER