BigInt

Beschreibung

Ein BigInt-Wert, auch manchmal einfach nur BigInt genannt, ist ein bigint Primitivtyp, der erstellt wird, indem n an das Ende eines ganzzahligen Literals angefügt wird, oder indem die BigInt()-Funktion (ohne den new-Operator) aufgerufen und ihr ein ganzzahliger oder ein string-Wert übergeben 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 einigen Aspekten ähnlich wie Number-Werte, unterscheiden sich jedoch in einigen wesentlichen Punkten: Ein BigInt-Wert kann nicht mit Methoden des eingebauten Math-Objekts verwendet werden und kann in Operationen nicht mit einem Number-Wert gemischt werden; sie müssen auf den gleichen Typ gebracht werden. Seien Sie jedoch vorsichtig beim Typwechsel der Werte, da die Genauigkeit eines BigInt-Werts verloren gehen kann, wenn er in einen Number-Wert umgewandelt wird.

Typinformationen

Wenn gegen typeof getestet wird, gibt ein BigInt-Wert (bigint Primitivtyp) "bigint" zurück:

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

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

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

Operatoren

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

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

Die Operatoren, die einen Booleschen Wert zurückgeben, erlauben eine Mischung von Zahlen und BigInts als Operanden:

• Relationale Operatoren und Gleichheitsoperatoren: >, <, >=, <=, ==, !=, ===, !==
• Logische Operatoren verlassen sich nur auf die Wahrhaftigkeit der Operanden.

Einige wenige Operatoren unterstützen BigInt überhaupt nicht:

• Unäres Plus (+) kann nicht unterstützt werden, da es in asm.js widersprüchlich genutzt wird, und wurde daher um asm.js nicht zu stören, weggelassen.
• Unsigned right shift (>>>) ist der einzige Bitoperator, der nicht unterstützt wird, da jeder BigInt-Wert vorzeichenbehaftet ist.

Spezialfälle:

• Addition (+) mit einem String und einem BigInt gibt einen String zurück.
• Division (/) kürzt zu Null hin ab, 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

Vergleiche

Ein BigInt-Wert ist nicht streng gleich einem Number-Wert, aber es ist locker so:

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

Ein Number-Wert 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 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 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-eingeschlossenen BigInt-Werten wie bei anderen Objekten funktionieren, wobei Gleichheit nur angezeigt wird, wenn dieselbe Objektinstanz verglichen wird:

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

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

Da der Typwechsel zwischen Number-Werten und BigInt-Werten zu einem Verlust an Genauigkeit führen kann, wird Folgendes empfohlen:

• Verwenden Sie einen BigInt-Wert nur, wenn Werte größer als 2⁵³ voraussichtlich auftreten.
• Vermeiden Sie den Typwechsel zwischen BigInt-Werten und Number-Werten.

Bedingte Anweisungen

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

• er in ein Boolean konvertiert wird: durch die Boolean-Funktion;
• wenn er mit logischen Operatoren ||, && und ! verwendet wird; oder
• innerhalb eines bedingten Tests wie einer if-Anweisung.

Genauer gesagt, nur 0n ist 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

Kryptographie

Die auf BigInt-Werten unterstützten Operationen sind nicht konstant in der Zeit und sind daher anfällig für Timing-Angriffe. JavaScript BigInts könnten daher gefährlich sein für den Einsatz in der Kryptographie ohne abschwächende Maßnahmen. Als sehr generisches Beispiel könnte ein Angreifer den Zeitunterschied zwischen 101n ** 65537n und 17n ** 9999n messen und die Größe von Geheimnissen, wie privaten Schlüsseln, basierend auf der verstrichenen Zeit ablesen. Falls Sie dennoch BigInts verwenden müssen, schauen Sie sich das Timing attack FAQ für allgemeine Ratschläge zu diesem Thema an.

Verwendung innerhalb von JSON

Die Verwendung von JSON.stringify() mit einem BigInt-Wert wird einen TypeError auslösen, da BigInt-Werte standardmäßig nicht in JSON serialisiert werden. Allerdings lässt JSON.stringify() speziell eine Hintertür für BigInt-Werte offen: Es wird versuchen, die toJSON() Methode des BigInt aufzurufen. (Das tut es bei keinem anderen Primitivwert.) Daher können Sie Ihre eigene toJSON() Methode implementieren (was einer der wenigen Fälle ist, in denen das Patchen von eingebauten Objekten nicht explizit entmutigt wird):

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

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

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

Falls Sie nicht BigInt.prototype 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 anschließend den reviver Parameter von JSON.parse nutzen, 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 }

In der Tat erlaubt JSON Zahlenliterale, die beliebig lang sind; sie können in JavaScript nur nicht mit voller Präzision geparst werden. Wenn Sie mit einem anderen Programm in einer Sprache kommunizieren, die längere Ganzzahlen (z. B. 64-Bit-Ganzzahlen) unterstützt, und Sie das BigInt als JSON-Zahl anstatt eines JSON-Strings übermitteln möchten, siehe verlustfreie Zahlen Serialisierung.

BigInt-Typwechsel

Viele eingebaute Operationen, die BigInts erwarten, konvertieren zuerst ihre Argumente zu BigInts. Die Operation kann wie folgt 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 analysiert werden, als ob sie ein Ganzzahlenliteral enthalten würden. Jeder Parsing-Fehler führt zu einem SyntaxError. Die Syntax ist ein Teil der stringnumerischen Literal, wobei Dezimalpunkte oder Exponentialindikatoren nicht erlaubt sind.
• Zahlen werfen einen TypeError, um ungewollte implizite Umwandlungen, die zu einem Verlust an Präzision führen, zu vermeiden.
• Symbole werfen einen TypeError.
• Objekte werden zuerst in ein Primärwert konvertiert, indem ihre [Symbol.toPrimitive]() (mit "number" als Hinweis), valueOf() und toString() Methoden, in dieser Reihenfolge, aufgerufen werden. Der resultierende Primärwert wird dann in ein BigInt konvertiert.

Der beste Weg, um annähernd den gleichen Effekt in JavaScript zu erzielen, ist die Verwendung der BigInt()-Funktion: BigInt(x) verwendet denselben Algorithmus, um x zu konvertieren, außer dass Zahlen keinen TypeError werfen, sondern in BigInts umgewandelt werden, wenn sie Ganzzahlen sind.

Beachten Sie, dass eingebaute Operationen, die BigInts erwarten, oft das BigInt nach dem Typwechsel auf eine feste Breite kürzen. Dies umfasst BigInt.asIntN(), BigInt.asUintN() und Methoden von BigInt64Array und BigUint64Array.

Konstruktor

BigInt()

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

Statische Methoden

BigInt.asIntN()

Kürzt einen BigInt-Wert auf die angegebene Anzahl der am wenigsten signifikanten Bits und gibt diesen als vorzeichenbehafteten Ganzzahl zurück.

BigInt.asUintN()

Kürzt einen BigInt-Wert auf die angegebene Anzahl der am wenigsten signifikanten Bits und gibt diesen als vorzeichenlose Ganzzahl zurück.

Instanz-Eigenschaften

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

BigInt.prototype.constructor

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

BigInt.prototype[Symbol.toStringTag]

Der ursprüngliche Wert der [Symbol.toStringTag]-Eigenschaft ist der String "BigInt". Diese Eigenschaft wird in Object.prototype.toString() verwendet. Da BigInt allerdings 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.

Instanz-Methoden

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 in der angegebenen Basis (Radix) darstellt. Überschreibt die Object.prototype.toString()-Methode.

BigInt.prototype.valueOf()

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

Beispiele

Primzahlen berechnen

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 value
function 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