BigInt

Ein BigInt-Wert, manchmal auch einfach ein BigInt genannt, ist ein bigint-Primitivtyp, der durch Anhängen von n an das Ende eines Integer-Literals oder durch Aufrufen der Funktion BigInt() (ohne den new-Operator) mit einem Integer- oder Stringwert erstellt wird.

const previouslyMaxSafeInteger = 9007199254740991n;

const alsoHuge = BigInt(9007199254740991);
// 9007199254740991n

const hugeString = BigInt("9007199254740991");
// 9007199254740991n

const hugeHex = BigInt("0x1fffffffffffff");
// 9007199254740991n

const hugeOctal = BigInt("0o377777777777777777");
// 9007199254740991n

const hugeBin = BigInt(
  "0b11111111111111111111111111111111111111111111111111111",
);
// 9007199254740991n

BigInt-Werte sind in gewisser Weise ähnlich wie Zahlenwerte, unterscheiden sich jedoch in einigen entscheidenden Punkten: Ein BigInt-Wert kann nicht mit Methoden im eingebauten Math-Objekt verwendet werden und kann nicht in Operationen mit einem Zahlenwert gemischt werden; sie müssen in den gleichen Typ gezwungen werden. Seien Sie jedoch vorsichtig, wenn Sie Werte hin und her zwingen, da die Präzision eines BigInt-Werts verloren gehen kann, wenn er in einen Zahlenwert umgewandelt wird.

Wenn ein BigInt-Wert (Primitivtyp bigint) gegen typeof getestet wird, ergibt er "bigint":

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

Ein BigInt-Wert kann auch in ein Object eingebettet werden:

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

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

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

Die Operatoren, die boolesche Werte zurückgeben, erlauben das Mischen von Zahlen und BigInts als Operanden:

• Relationale Operatoren und Gleichheitsoperatoren: >, <, >=, <=, ==, !=, ===, !==
• Logische Operatoren verlassen sich nur auf die Wahrheit von Operanden

Einige Operatoren unterstützen BigInt überhaupt nicht:

• Einheitliches Plus (+) kann aufgrund der Konfliktverwendung in asm.js nicht unterstützt werden, sodass es um asm.js nicht zu brechen weggelassen wurde.
• Unsigned Right Shift (>>>) ist der einzige bitweise Operator, der nicht unterstützt wird, da jeder BigInt-Wert signiert ist.

Spezialfälle:

• Die Addition (+) eines Strings und eines BigInt ergibt einen String.
• Die Division (/) kürzt Bruchteile in Richtung null, da BigInt keine Bruchzahlen darstellen kann.

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

Ein BigInt-Wert ist nicht strikt gleich einem Zahlenwert, aber es ist lose so:

0n === 0; // false
0n == 0; // true

Ein Zahlenwert und ein BigInt-Wert können wie gewöhnlich verglichen werden:

1n < 2; // true
2n > 1; // true
2 > 2; // false
2n > 2; // false
2n >= 2; // true

BigInt-Werte und Zahlenwerte 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 comparator
mixed.sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
// [ -12n, 0, 0n, 4n, 4, 6, 10 ]

Beachten Sie, dass Vergleiche mit Object-eingebetteten BigInt-Werten wie bei anderen Objekten nur Gleichheit anzeigen, wenn dieselbe Objektinstanz verglichen wird:

Object(0n) === 0n; // false
Object(0n) === Object(0n); // false

const o = Object(0n);
o === o; // true

Da das Umwandeln zwischen Zahlenwerten und BigInt-Werten zum Verlust der Präzision führen kann, wird Folgendes empfohlen:

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

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

• er in einen Boolean umgewandelt wird: über die Boolean-Funktion;
• bei Verwendung mit logischen Operatoren ||, &&, und !; oder
• innerhalb eines bedingten Tests wie einer if-Anweisung.

Genauer gesagt ist nur 0n falsch; alles andere ist wahr.

if (0n) {
  console.log("Hello from the if!");
} else {
  console.log("Hello from the else!");
}
// "Hello from the else!"

0n || 12n; // 12n
0n && 12n; // 0n
Boolean(0n); // false
Boolean(12n); // true
!12n; // false
!0n; // true

Die auf BigInt-Werten unterstützten Operationen sind nicht konstant und daher anfällig für Timing-Angriffe. JavaScript BigInts könnten daher gefährlich für die Verwendung in der Kryptographie ohne mildernde Faktoren sein. Als ein sehr generisches Beispiel könnte ein Angreifer den Zeitunterschied zwischen 101n ** 65537n und 17n ** 9999n messen und die Größe geheimer Daten wie privater Schlüssel anhand der vergangenen Zeit ableiten. Wenn Sie dennoch BigInts verwenden müssen, werfen Sie einen Blick auf das Timing-Angriff FAQ für allgemeine Ratschläge zu diesem Problem.

Die Verwendung von JSON.stringify() mit einem BigInt-Wert führt zu einem TypeError, da BigInt-Werte standardmäßig nicht in JSON serialisiert werden. JSON.stringify() hinterlässt jedoch speziell eine Hintertür für BigInt-Werte: Es würde versuchen, die toJSON()-Methode des BigInt zu rufen. (Dies geschieht bei keinen anderen Primitivwerten.) Sie können daher Ihre eigene toJSON()-Methode implementieren (eine der wenigen Fälle, in denen das Patching von eingebauten Objekten nicht explizit abgeraten wird):

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

Statt zu werfen, erzeugt JSON.stringify() nun einen String wie diesen:

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

Wenn Sie BigInt.prototype nicht patchen möchten, können Sie den replacer-Parameter von JSON.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 den reviver-Parameter von JSON.parse verwenden, um diese zu behandeln:

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 beliebig lang sind; sie können jedoch in JavaScript nicht vollständig präzise geparst werden. Wenn Sie mit einem anderen Programm in einer Sprache kommunizieren, die längere Ganzzahlen unterstützt (wie z.B. 64-Bit-Ganzzahlen), und Sie das BigInt als JSON-Zahl statt als JSON-String übertragen möchten, siehe Verlustfreie Zahlenserialisierung.

Viele eingebaute Operationen, die BigInts erwarten, zwingen zunächst ihre Argumente zu BigInts. Die Operation kann folgendermaßen zusammengefasst werden:

• BigInts werden unverändert zurückgegeben.
• undefined und null werfen einen TypeError.
• true wird zu 1n; false wird zu 0n.
• Strings werden konvertiert, indem sie geparst werden, als ob sie ein Integer-Literal enthalten. Jeder Parsing-Fehler resultiert in einem SyntaxError. Die Syntax ist ein Subset von string-numerischen Literalen, wobei Dezimalpunkte oder Exponentenindikatoren nicht erlaubt sind.
• Zahlen werfen einen TypeError, um unbeabsichtigte implizite Typumwandlungen, die zu einem Verlust der Präzision führen könnten, zu verhindern.
• Symbole werfen einen TypeError.
• Objekte werden zuerst in einen Primitivwert konvertiert, indem ihre Methoden [Symbol.toPrimitive]() (mit “number” als Hinweis), valueOf() und toString() in dieser Reihenfolge aufgerufen werden. Der resultierende Primitivwert wird dann in einen BigInt konvertiert.

Der beste Weg, fast denselben Effekt in JavaScript zu erzielen, ist die Verwendung der BigInt()-Funktion: BigInt(x) verwendet denselben Algorithmus, um x umzuwandeln, außer dass Zahlen keinen TypeError werfen, sondern konvertiert werden, wenn sie Ganzzahlen sind.

Beachten Sie, dass eingebaute Operationen, die BigInts erwarten, häufig den BigInt nach der Umwandlung auf eine feste Breite kürzen. Dies schließt BigInt.asIntN(), BigInt.asUintN() sowie Methoden von BigInt64Array und BigUint64Array ein.

BigInt()

Gibt primitive Werte vom Typ BigInt zurück. Wirft einen Fehler, wenn mit new aufgerufen.

BigInt.asIntN()

Begrenzt einen BigInt-Wert auf einen signierten Integer-Wert und gibt diesen Wert zurück.

BigInt.asUintN()

Begrenzt einen BigInt-Wert auf einen unsignierten Integer-Wert und gibt diesen Wert zurück.

Diese Eigenschaften sind auf BigInt.prototype definiert und werden von allen BigInt-Instanzen geteilt.

BigInt.prototype.constructor

Die Konstruktorfunktion, die das Instanzobjekt erstellt hat. Für BigInt-Instanzen ist der Anfangswert der BigInt-Konstruktor.

BigInt.prototype[Symbol.toStringTag]

Der Anfangswert der [Symbol.toStringTag]-Eigenschaft ist der String "BigInt". Diese Eigenschaft wird in Object.prototype.toString() verwendet. Da BigInt jedoch auch seine eigene toString()-Methode hat, wird diese Eigenschaft nicht verwendet, es sei denn, Sie rufen Object.prototype.toString.call() mit einem BigInt als thisArg auf.

BigInt.prototype.toLocaleString()

Gibt einen string mit einer sprachsensitiven Darstellung dieses BigInt-Werts zurück. Überschreibt die Object.prototype.toLocaleString()-Methode.

BigInt.prototype.toString()

Gibt einen String zurück, der diesen BigInt-Wert im angegebenen Radix (Basis) darstellt. Überschreibt die Object.prototype.toString()-Methode.

BigInt.prototype.valueOf()

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

• Number
• Number.MAX_SAFE_INTEGER