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 angefgt 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 mssen 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" zurck:

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 untersttzen BigInts, jedoch erlauben die meisten keine Operanden von gemischten Typen beide Operanden mssen BigInt sein oder keiner:

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

Die Operatoren, die einen Booleschen Wert zurckgeben, 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 untersttzen BigInt berhaupt nicht:

• Unres Plus (+) kann nicht untersttzt werden, da es in asm.js widersprchlich genutzt wird, und wurde daher um asm.js nicht zu stren, weggelassen.
• Unsigned right shift (>>>) ist der einzige Bitoperator, der nicht untersttzt wird, da jeder BigInt-Wert vorzeichenbehaftet ist.

Spezialflle:

• Addition (+) mit einem String und einem BigInt gibt einen String zurck.
• Division (/) krzt 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 knnen wie gewhnlich verglichen werden:

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

BigInt-Werte und Number-Werte knnen 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 fhren kann, wird Folgendes empfohlen:

• Verwenden Sie einen BigInt-Wert nur, wenn Werte grer als 253 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 untersttzten Operationen sind nicht konstant in der Zeit und sind daher anfllig fr Timing-Angriffe. JavaScript BigInts knnten daher gefhrlich sein fr den Einsatz in der Kryptographie ohne abschwchende Manahmen. Als sehr generisches Beispiel knnte ein Angreifer den Zeitunterschied zwischen 101n ** 65537n und 17n ** 9999n messen und die Gre von Geheimnissen, wie privaten Schlsseln, basierend auf der verstrichenen Zeit ablesen. Falls Sie dennoch BigInts verwenden mssen, schauen Sie sich das Timing attack FAQ fr allgemeine Ratschlge zu diesem Thema an.

Verwendung innerhalb von JSON

Die Verwendung von JSON.stringify() mit einem BigInt-Wert wird einen TypeError auslsen, da BigInt-Werte standardmig nicht in JSON serialisiert werden. Allerdings lsst JSON.stringify() speziell eine Hintertr fr BigInt-Werte offen: Es wird versuchen, die toJSON() Methode des BigInt aufzurufen. (Das tut es bei keinem anderen Primitivwert.) Daher knnen Sie Ihre eigene toJSON() Methode implementieren (was einer der wenigen Flle 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 mchten, knnen 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 knnen anschlieend 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 knnen in JavaScript nur nicht mit voller Przision geparst werden. Wenn Sie mit einem anderen Programm in einer Sprache kommunizieren, die lngere Ganzzahlen (z. B. 64-Bit-Ganzzahlen) untersttzt, und Sie das BigInt als JSON-Zahl anstatt eines JSON-Strings bermitteln mchten, 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 unverndert zurckgegeben.
• 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 wrden. Jeder Parsing-Fehler fhrt 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 Przision fhren, zu vermeiden.
• Symbole werfen einen TypeError.
• Objekte werden zuerst in ein Primrwert konvertiert, indem ihre [Symbol.toPrimitive]() (mit "number" als Hinweis), valueOf() und toString() Methoden, in dieser Reihenfolge, aufgerufen werden. Der resultierende Primrwert wird dann in ein BigInt konvertiert.

Der beste Weg, um annhernd den gleichen Effekt in JavaScript zu erzielen, ist die Verwendung der BigInt()-Funktion: BigInt(x) verwendet denselben Algorithmus, um x zu konvertieren, auer 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 krzen. Dies umfasst BigInt.asIntN(), BigInt.asUintN() und Methoden von BigInt64Array und BigUint64Array.

Konstruktor

BigInt()

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

Statische Methoden

BigInt.asIntN()

Krzt einen BigInt-Wert auf die angegebene Anzahl der am wenigsten signifikanten Bits und gibt diesen als vorzeichenbehafteten Ganzzahl zurck.

BigInt.asUintN()

Krzt einen BigInt-Wert auf die angegebene Anzahl der am wenigsten signifikanten Bits und gibt diesen als vorzeichenlose Ganzzahl zurck.

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. Fr BigInt-Instanzen ist der Anfangswert der BigInt-Konstruktor.

BigInt.prototype[Symbol.toStringTag]

Der ursprngliche 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 zurck. berschreibt die Object.prototype.toLocaleString()-Methode.

BigInt.prototype.toString()

Gibt einen String zurck, der diesen BigInt-Wert in der angegebenen Basis (Radix) darstellt. berschreibt die Object.prototype.toString()-Methode.

BigInt.prototype.valueOf()

Gibt diesen BigInt-Wert zurck. 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-Kompatibilitt

Siehe auch

• Number
• Number.MAX_SAFE_INTEGER