Signatur
Beschreibung
BigInt ist ein eingebauter Primitiv-Typ in JavaScript, der Ganzzahlen beliebiger Größe speichern und verarbeiten kann. Normale Number-Werte verlieren bei sehr großen oder sehr kleinen Ganzzahlen ihre Präzision (ab Number.MAX_SAFE_INTEGER = 253 − 1). BigInt umgeht diese Einschränkung vollständig.
Ein BigInt-Literal wird durch ein nachgestelltes n erzeugt: 9007199254740993n. Alternativ kann die Funktion BigInt(value) aufgerufen werden, um aus einem String oder einer Zahl ein BigInt zu erstellen. Wichtig: BigInt-Werte können nicht mit regulären Number-Werten in arithmetischen Operationen gemischt werden — beide Operanden müssen vom gleichen Typ sein, sonst wird ein TypeError geworfen.
Typische Anwendungsfälle sind: Kryptografie, präzise Zeitstempel in Nanosekunden, Finanzberechnungen mit großen Ganzzahlen sowie die Arbeit mit 64-Bit-Werten aus WebAssembly oder nativen APIs. Vergleiche zwischen BigInt und Number sind über == (loose equality) möglich, aber kein ===-Gleichheitsvergleich verschiedener Typen liefert true.
- Arithmetik: Alle gängigen Operatoren (
+,-,*,/,%,**) und bitweise Operatoren werden unterstützt. Division liefert eine gekürzte Ganzzahl (kein Rest). - Keine Dezimalstellen:
BigIntkann keine Bruchteile darstellen — nur ganzzahlige Werte. - JSON:
JSON.stringifywirft einen Fehler beiBigInt-Werten, sofern kein benutzerdefiniertertoJSON-Replacer verwendet wird.
Parameter
| Name | Typ | Default | Beschreibung |
|---|---|---|---|
| $value Pflicht | number|string|boolean|BigInt | Der Wert, der in ein BigInt konvertiert werden soll. Strings müssen eine gültige Ganzzahl-Darstellung enthalten (z. B. "42" oder "0xFF"). Dezimalzahlen wie 1.5 werfen einen RangeError. |
Rückgabewert
bigint-Wert, der die übergebene Ganzzahl exakt repräsentiert.Beispiele
Grundlegende BigInt-Erstellung und Arithmetik
// Literal-Syntax mit 'n'-Suffix
const a = 9007199254740991n; // Number.MAX_SAFE_INTEGER als BigInt
const b = 1n;
console.log(a + b); // 9007199254740992n — exakt!
// Mit Number wäre das ungenau:
console.log(9007199254740991 + 1); // 9007199254740992 — zufällig korrekt
console.log(9007199254740991 + 2); // 9007199254740992 — FALSCH (Präzisionsverlust)
console.log(9007199254740991n + 2n); // 9007199254740993n — korrekt
// Konstruktor-Aufruf
const fromString = BigInt("123456789012345678901234567890");
console.log(fromString); // 123456789012345678901234567890nTypvergleiche, Konvertierung und JSON-Serialisierung
const big = 42n;
const num = 42;
// Vergleiche
console.log(big == num); // true (lose Gleichheit)
console.log(big === num); // false (strenger Typvergleich)
console.log(big > 10n); // true
// Konvertierung
console.log(Number(big)); // 42
console.log(String(big)); // "42"
console.log(typeof big); // "bigint"
// Gemischte Arithmetik wirft TypeError:
try {
const result = big + num;
} catch (e) {
console.error(e.message); // Cannot mix BigInt and other types
}
// JSON-Serialisierung mit benutzerdefiniertem Replacer:
const data = { id: 9007199254740993n, name: "Eintrag" };
const json = JSON.stringify(data, (key, value) =>
typeof value === "bigint" ? value.toString() : value
);
console.log(json); // {"id":"9007199254740993","name":"Eintrag"}Statische Methoden: asIntN und asUintN
// BigInt.asIntN(width, value) — kürzt auf vorzeichenbehaftete N-Bit-Ganzzahl
const signed = BigInt.asIntN(8, 200n); // 200 passt nicht in 8-Bit signed => -56
console.log(signed); // -56n
// BigInt.asUintN(width, value) — kürzt auf vorzeichenlose N-Bit-Ganzzahl
const unsigned = BigInt.asUintN(8, 300n); // 300 mod 256 = 44
console.log(unsigned); // 44n
// Nützlich z. B. für 64-Bit-Berechnungen ohne Überlauf:
const MAX_U64 = 2n ** 64n;
const wrapped = BigInt.asUintN(64, MAX_U64); // 0n (Überlauf)
console.log(wrapped); // 0n// Wichtig · Fallstricke
Browser-Kompatibilität: BigInt wird seit Chrome 67, Firefox 68, Safari 14 und Node.js 10.3 unterstützt. Internet Explorer unterstützt BigInt nicht.
Kein new BigInt(): BigInt ist keine Konstruktorfunktion — der Aufruf mit new BigInt() wirft einen TypeError. Nur der Direktaufruf BigInt(value) oder das Literal 42n sind zulässig.
Math-Objekt: Die Methoden von Math (z. B. Math.max, Math.sqrt) akzeptieren keine BigInt-Werte und werfen einen TypeError. Für solche Operationen muss explizit nach Number konvertiert werden, wobei Präzisionsverlust möglich ist.
Performance: Operationen mit BigInt sind deutlich langsamer als mit Number. Sie sollten nur eingesetzt werden, wenn der Wertebereich von Number tatsächlich nicht ausreicht.