JavaScript BigInt: Ein umfassender Leitfaden zur Berechnung großer Zahlen

Viele Jahre lang sahen sich JavaScript-Entwickler einer stillen, aber bedeutenden Einschränkung gegenüber: der nativen Fähigkeit der Sprache, mit Zahlen umzugehen. Obwohl der Number-Typ von JavaScript für alltägliche Berechnungen perfekt geeignet ist, scheiterte er, wenn er mit den wirklich riesigen Ganzzahlen konfrontiert wurde, die in Bereichen wie Kryptografie, wissenschaftlichem Rechnen und modernen Datensystemen erforderlich sind. Dies führte zu einer Welt von Umgehungslösungen, Drittanbieter-Bibliotheken und subtilen, schwer zu debuggenden Präzisionsfehlern.

Diese Ära ist vorbei. Die Einführung von BigInt als nativer primitiver Typ in JavaScript hat die Art und Weise, wie wir mit großen Zahlen arbeiten, revolutioniert. Es bietet eine robuste, ergonomische und effiziente Methode zur Durchführung von Ganzzahlarithmetik mit beliebiger Präzision, direkt innerhalb der Sprache.

Dieser umfassende Leitfaden richtet sich an Entwickler auf der ganzen Welt. Wir werden tief in das „Warum, Was und Wie“ von BigInt eintauchen. Ob Sie eine Finanzanwendung erstellen, mit einer Blockchain interagieren oder einfach nur versuchen zu verstehen, warum sich Ihre große eindeutige ID von einer API seltsam verhält – dieser Artikel wird Sie mit dem Wissen ausstatten, um BigInt zu meistern.

Das Problem: Die Grenzen des Number-Typs in JavaScript

Bevor wir die Lösung würdigen können, müssen wir das Problem vollständig verstehen. JavaScript hatte die meiste Zeit seiner Geschichte nur einen Zahlentyp: den Number-Typ. Unter der Haube wird er als IEEE 754 64-Bit-Gleitkommazahl mit doppelter Genauigkeit dargestellt. Dieses Format eignet sich hervorragend zur Darstellung eines breiten Wertebereichs, einschließlich Dezimalzahlen, hat aber eine entscheidende Einschränkung, wenn es um Ganzzahlen geht.

Wir stellen vor: MAX_SAFE_INTEGER

Aufgrund seiner Gleitkommadarstellung gibt es eine Grenze für die Größe einer Ganzzahl, die mit perfekter Präzision dargestellt werden kann. Diese Grenze wird durch eine Konstante offengelegt: Number.MAX_SAFE_INTEGER.

Sein Wert ist 2⁵³ - 1, was 9,007,199,254,740,991 ist. Nennen wir es der Einfachheit halber neun Billiarden.

Jede Ganzzahl im Bereich von -Number.MAX_SAFE_INTEGER bis +Number.MAX_SAFE_INTEGER gilt als „sichere Ganzzahl“. Das bedeutet, sie kann exakt dargestellt und korrekt verglichen werden. Aber was passiert, wenn wir diesen Bereich verlassen?

Sehen wir es uns in Aktion an:

            const maxSafe = Number.MAX_SAFE_INTEGER;
console.log(maxSafe);        // 9007199254740991

// Addieren wir 1 hinzu
console.log(maxSafe + 1);    // 9007199254740992 - Das sieht korrekt aus

// Addieren wir eine weitere 1
console.log(maxSafe + 2);    // 9007199254740992 - Oh oh. Falsches Ergebnis.

// Es wird schlimmer
console.log(maxSafe + 3);    // 9007199254740994 - Moment, was?
console.log(maxSafe + 4);    // 9007199254740996 - Es überspringt Zahlen!

// Die Gleichheitsprüfung schlägt ebenfalls fehl
console.log(maxSafe + 1 === maxSafe + 2); // true - Das ist mathematisch falsch!
            

              
                Copy
              
            
          

Wie Sie sehen, kann JavaScript die Präzision unserer Berechnungen nicht mehr garantieren, sobald wir Number.MAX_SAFE_INTEGER überschreiten. Die Zahlendarstellung beginnt, Lücken aufzuweisen, was zu Rundungsfehlern und falschen Ergebnissen führt. Dies ist ein Albtraum für Anwendungen, die Genauigkeit bei großen Ganzzahlen erfordern.

Die alten Umgehungslösungen

Jahrelang verließ sich die globale Entwicklergemeinschaft auf externe Bibliotheken, um dieses Problem zu lösen. Bibliotheken wie bignumber.js, decimal.js und long.js wurden zu Standardwerkzeugen. Sie funktionierten, indem sie große Zahlen als Zeichenketten oder Arrays von Ziffern darstellten und arithmetische Operationen in Software implementierten.

Obwohl diese Bibliotheken effektiv waren, hatten sie Kompromisse:

• Performance-Overhead: Operationen waren deutlich langsamer als native Zahlenberechnungen.
• Bundle-Größe: Sie erhöhten das Gewicht der Anwendungs-Bundles, ein Problem für die Web-Performance.
• Andere Syntax: Entwickler mussten Objektmethoden (z. B. a.add(b)) anstelle von Standard-Rechenoperatoren (a + b) verwenden, was den Code weniger intuitiv machte.

Einführung von BigInt: Die native Lösung

BigInt wurde in ES2020 eingeführt, um dieses Problem nativ zu lösen. Ein BigInt ist ein neuer primitiver Typ in JavaScript, der eine Möglichkeit bietet, ganze Zahlen darzustellen, die größer als 2⁵³ - 1 sind.

Das Hauptmerkmal von BigInt ist, dass seine Größe nicht festgelegt ist. Es kann beliebig große Ganzzahlen darstellen, die nur durch den verfügbaren Speicher im Host-System begrenzt sind. Dies beseitigt die Präzisionsprobleme, die wir beim Number-Typ gesehen haben, vollständig.

Wie man ein BigInt erstellt

Es gibt zwei primäre Wege, ein BigInt zu erstellen:

1. Anhängen von `n` an ein Ganzzahlliteral: Dies ist die einfachste und gebräuchlichste Methode.
2. Verwendung der Konstruktorfunktion `BigInt()`: Dies ist nützlich, wenn ein Wert von einem anderen Typ, wie einer Zeichenkette oder einer Zahl, konvertiert wird.

So sieht das im Code aus:

            // 1. Verwendung des 'n'-Suffixes
const myFirstBigInt = 900719925474099199n;
const anotherBigInt = 123456789012345678901234567890n;

// 2. Verwendung des BigInt()-Konstruktors
const fromString = BigInt("98765432109876543210");
const fromNumber = BigInt(100);

// Sie können den Typ überprüfen
console.log(typeof myFirstBigInt); // "bigint"
console.log(typeof 100);          // "number"
            

              
                Copy
              
            
          

Mit BigInt funktioniert unsere zuvor fehlgeschlagene Berechnung jetzt perfekt:

            const maxSafePlusOne = BigInt(Number.MAX_SAFE_INTEGER) + 1n;
const maxSafePlusTwo = BigInt(Number.MAX_SAFE_INTEGER) + 2n;

console.log(maxSafePlusOne.toString());    // "9007199254740992"
console.log(maxSafePlusTwo.toString());    // "9007199254740993"

// Die Gleichheit funktioniert wie erwartet
console.log(maxSafePlusOne === maxSafePlusTwo); // false
            

              
                Copy
              
            
          

Arbeiten mit BigInt: Syntax und Operationen

BigInts verhalten sich ähnlich wie reguläre Zahlen, jedoch mit einigen entscheidenden Unterschieden, die jeder Entwickler verstehen muss, um Fehler zu vermeiden.

Arithmetische Operationen

Alle Standard-Rechenoperatoren funktionieren mit BigInts:

• Addition: +
• Subtraktion: -
• Multiplikation: *
• Potenzierung: **
• Modulo (Rest): %

Der eine Operator, der sich anders verhält, ist die Division (`/`).

            const a = 10n;
const b = 3n;

console.log(a + b); // 13n
console.log(a - b); // 7n
console.log(a * b); // 30n
console.log(a ** b); // 1000n
console.log(a % b); // 1n
            

              
                Copy
              
            
          

Der Vorbehalt bei der Division

Da BigInts nur ganze Zahlen darstellen können, wird das Ergebnis einer Division immer abgeschnitten (der Bruchteil wird verworfen). Es wird nicht gerundet.

            const a = 10n;
const b = 3n;
console.log(a / b); // 3n (nicht 3.333...n)

const c = 9n;
const d = 10n;
console.log(c / d); // 0n
            

              
                Copy
              
            
          

Dies ist ein entscheidender Unterschied. Wenn Sie Berechnungen mit Dezimalzahlen durchführen müssen, ist BigInt nicht das richtige Werkzeug. Sie müssten weiterhin Number oder eine dedizierte Dezimalbibliothek verwenden.

Vergleich und Gleichheit

Vergleichsoperatoren wie >, <, >= und <= funktionieren nahtlos zwischen BigInts und sogar zwischen einem BigInt und einer Number.

            console.log(10n > 5);   // true
console.log(10n < 20);  // true
console.log(10n > 20n); // false
            

              
                Copy
              
            
          

Die Gleichheit ist jedoch nuancierter und eine häufige Quelle der Verwirrung.

• Lose Gleichheit (`==`): Dieser Operator führt eine Typumwandlung (Type Coercion) durch. Er betrachtet ein BigInt und eine Number mit demselben mathematischen Wert als gleich.
• Strikte Gleichheit (`===`): Dieser Operator führt keine Typumwandlung durch. Da BigInt und Number unterschiedliche Typen sind, wird er beim Vergleich immer false zurückgeben.

            console.log(10n == 10);  // true - Seien Sie vorsichtig damit!
console.log(10n === 10); // false - Zur Klarheit empfohlen.

console.log(0n == 0);   // true
console.log(0n === 0);  // false
            

              
                Copy
              
            
          

Best Practice: Um subtile Fehler zu vermeiden, verwenden Sie immer die strikte Gleichheit (`===`) und seien Sie explizit bei den Typen, die Sie vergleichen. Wenn Sie ein BigInt und eine Number vergleichen müssen, ist es oft klarer, eines zuerst in das andere zu konvertieren und dabei einen möglichen Präzisionsverlust zu berücksichtigen.

Der Typenkonflikt: Eine strikte Trennung

JavaScript erzwingt eine strikte Regel: Sie können BigInt- und Number-Operanden in den meisten arithmetischen Operationen nicht mischen.

Der Versuch, dies zu tun, führt zu einem TypeError. Dies ist eine bewusste Designentscheidung, um zu verhindern, dass Entwickler versehentlich an Präzision verlieren.

            const myBigInt = 100n;
const myNumber = 50;

try {
  const result = myBigInt + myNumber; // Dies wird einen Fehler auslösen
} catch (error) {
  console.log(error); // TypeError: Cannot mix BigInt and other types, use explicit conversions
}
            

              
                Copy
              
            
          

Der korrekte Ansatz: Explizite Konvertierung

Um eine Operation zwischen einem BigInt und einer Number durchzuführen, müssen Sie eines von beiden explizit konvertieren.

            const myBigInt = 100n;
const myNumber = 50;

// Number zu BigInt konvertieren (sicher)
const result1 = myBigInt + BigInt(myNumber);
console.log(result1); // 150n

// BigInt zu Number konvertieren (potenziell unsicher!)
const veryLargeBigInt = 900719925474099199n;

// Dies führt zu Präzisionsverlust!
const unsafeNumber = Number(veryLargeBigInt);
console.log(unsafeNumber); // 900719925474099200 - Der Wert wurde gerundet!

const safeResult = Number(100n) + myNumber;
console.log(safeResult); // 150
            

              
                Copy
              
            
          

Kritische Regel: Konvertieren Sie ein BigInt nur dann in eine Number, wenn Sie absolut sicher sind, dass es in den sicheren Ganzzahlbereich passt. Andernfalls konvertieren Sie immer die Number in ein BigInt, um die Präzision zu erhalten.

Praktische Anwendungsfälle für BigInt im globalen Kontext

Der Bedarf an BigInt ist kein abstraktes akademisches Problem. Es löst reale Herausforderungen, mit denen Entwickler in verschiedenen internationalen Bereichen konfrontiert sind.

1. Hochpräzise Zeitstempel

JavaScript's `Date.now()` gibt die Anzahl der Millisekunden seit der Unix-Epoche zurück. Obwohl dies für viele Webanwendungen ausreicht, ist es für Hochleistungssysteme nicht granular genug. Viele verteilte Systeme, Datenbanken und Logging-Frameworks auf der ganzen Welt verwenden Zeitstempel mit Nanosekunden-Präzision, um Ereignisse genau zu ordnen. Diese Zeitstempel werden oft als 64-Bit-Ganzzahlen dargestellt, die für den Number-Typ zu groß sind.

            // Ein Zeitstempel von einem hochauflösenden System (z.B. in Nanosekunden)
const nanoTimestampStr = "1670000000123456789";

// Die Verwendung von Number führt zu Präzisionsverlust
const lostPrecision = Number(nanoTimestampStr);
console.log(lostPrecision); // 1670000000123456800 - Falsch!

// Mit BigInt bleibt er perfekt erhalten
const correctTimestamp = BigInt(nanoTimestampStr);
console.log(correctTimestamp.toString()); // "1670000000123456789"

// Wir können nun genaue Berechnungen durchführen
const oneSecondInNanos = 1_000_000_000n;
const nextSecond = correctTimestamp + oneSecondInNanos;
console.log(nextSecond.toString()); // "1670001000123456789"
            

              
                Copy
              
            
          

2. Eindeutige Identifikatoren (IDs) von APIs

Ein sehr häufiges Szenario ist die Interaktion mit APIs, die 64-Bit-Ganzzahlen für eindeutige Objekt-IDs verwenden. Dies ist ein Muster, das von großen globalen Plattformen wie Twitter (Snowflake IDs) und vielen Datenbanksystemen (z. B. BIGINT-Typ in SQL) verwendet wird.

Wenn Sie Daten von einer solchen API abrufen, könnte der JSON-Parser in Ihrem Browser oder Ihrer Node.js-Umgebung versuchen, diese große ID als Number zu parsen, was zu Datenkorruption führt, bevor Sie überhaupt die Möglichkeit haben, damit zu arbeiten.

            // Eine typische JSON-Antwort von einer API
// Hinweis: Die ID ist eine große Zahl, keine Zeichenkette.
const jsonResponse = '{"id": 1367874743838343168, "text": "Hello, world!"}';

// Standardmäßiges JSON.parse wird die ID beschädigen
const parsedData = JSON.parse(jsonResponse);
console.log(parsedData.id); // 1367874743838343200 - Falsche ID!

// Lösung: Stellen Sie sicher, dass die API große IDs als Zeichenketten sendet.
const safeJsonResponse = '{"id": "1367874743838343168", "text": "Hello, world!"}';

const safeParsedData = JSON.parse(safeJsonResponse);
const userId = BigInt(safeParsedData.id);
console.log(userId); // 1367874743838343168n - Korrekt!
            

              
                Copy
              
            
          

Deshalb ist es eine weithin anerkannte Best Practice für APIs weltweit, große Ganzzahl-IDs als Zeichenketten in JSON-Payloads zu serialisieren, um die Kompatibilität mit allen Clients zu gewährleisten.

3. Kryptografie

Moderne Kryptografie basiert auf Mathematik, die extrem große Ganzzahlen involviert. Algorithmen wie RSA beruhen auf Operationen mit Zahlen, die Hunderte oder sogar Tausende von Bits lang sind. BigInt ermöglicht es, diese Berechnungen nativ in JavaScript durchzuführen, was für webbasierte kryptografische Anwendungen unerlässlich ist, wie z.B. solche, die die Web Crypto API verwenden oder Protokolle in Node.js implementieren.

Obwohl ein vollständiges kryptografisches Beispiel komplex ist, können wir eine konzeptionelle Demonstration sehen:

            // Zwei sehr große Primzahlen (nur zu Demonstrationszwecken)
const p = 1143400375533529n;
const q = 982451653n; // Eine kleinere für das Beispiel

// Bei RSA multipliziert man sie, um den Modul zu erhalten
const n = p * q;
console.log(n.toString()); // "1123281328905333100311297"

// Diese Berechnung wäre mit dem Number-Typ unmöglich.
// BigInt bewältigt dies mühelos.
            

              
                Copy
              
            
          

4. Finanz- und Blockchain-Anwendungen

Im Finanzwesen, insbesondere im Kontext von Kryptowährungen, ist Präzision von größter Bedeutung. Viele Kryptowährungen, wie Bitcoin, messen den Wert in ihrer kleinsten Einheit (z.B. Satoshis). Die Gesamtmenge dieser Einheiten kann Number.MAX_SAFE_INTEGER leicht überschreiten. BigInt ist das perfekte Werkzeug, um diese großen, präzisen Mengen zu handhaben, ohne auf Gleitkomma-Arithmetik zurückgreifen zu müssen, die anfällig für Rundungsfehler ist.

            // 1 Bitcoin = 100.000.000 Satoshis
const satoshisPerBTC = 100_000_000n;

// Die Gesamtmenge an Bitcoin beträgt 21 Millionen
const totalBTCSupply = 21_000_000n;

// Berechne die Gesamtzahl der Satoshis
const totalSatoshis = totalBTCSupply * satoshisPerBTC;

// 2.100.000.000.000.000 - Das sind 2,1 Billiarden
console.log(totalSatoshis.toString());

// Dieser Wert ist größer als Number.MAX_SAFE_INTEGER
console.log(totalSatoshis > BigInt(Number.MAX_SAFE_INTEGER)); // true
            

              
                Copy
              
            
          

Fortgeschrittene Themen und häufige Fallstricke

Serialisierung und JSON.stringify()

Eines der häufigsten Probleme, mit denen Entwickler konfrontiert werden, ist die Serialisierung von Objekten, die BigInts enthalten. Standardmäßig weiß JSON.stringify() nicht, wie es mit dem bigint-Typ umgehen soll, und löst einen TypeError aus.

            const data = {
  id: 12345678901234567890n,
  user: 'alex'
};

try {
  JSON.stringify(data);
} catch (error) {
  console.log(error); // TypeError: Do not know how to serialize a BigInt
}
            

              
                Copy
              
            
          

Lösung 1: Implementieren einer `toJSON`-Methode

Sie können JSON.stringify mitteilen, wie es mit BigInts umgehen soll, indem Sie eine `toJSON`-Methode zum `BigInt.prototype` hinzufügen. Dieser Ansatz patcht den globalen Prototyp, was in einigen gemeinsam genutzten Umgebungen unerwünscht sein könnte, aber er ist sehr effektiv.

            // Ein globaler Patch. Mit Bedacht verwenden.
BigInt.prototype.toJSON = function() {
  return this.toString();
};

const data = { id: 12345678901234567890n, user: 'alex' };
const jsonString = JSON.stringify(data);

console.log(jsonString); // '{"id":"12345678901234567890","user":"alex"}'
            

              
                Copy
              
            
          

Lösung 2: Verwenden einer Replacer-Funktion

Ein sichererer, stärker lokalisierter Ansatz ist die Verwendung des `replacer`-Arguments in `JSON.stringify`. Diese Funktion wird für jedes Schlüssel-Wert-Paar aufgerufen und ermöglicht es Ihnen, den Wert vor der Serialisierung zu transformieren.

            const data = { id: 12345678901234567890n, user: 'alex' };

const replacer = (key, value) => {
  if (typeof value === 'bigint') {
    return value.toString();
  }
  return value;
};

const jsonString = JSON.stringify(data, replacer);

console.log(jsonString); // '{"id":"12345678901234567890","user":"alex"}'
            

              
                Copy
              
            
          

Bitweise Operationen

BigInt unterstützt alle bitweisen Operatoren, die Sie vom Number-Typ kennen: `&` (AND), `|` (OR), `^` (XOR), `~` (NOT), `<<` (Linksshift) und `>>` (vorzeichenerhaltender Rechtsshift). Diese sind besonders nützlich bei der Arbeit mit Low-Level-Datenformaten, Berechtigungen oder bestimmten Arten von Algorithmen.

            const permissions = 5n; // 0101 in binär
const READ_PERMISSION = 4n;   // 0100
const WRITE_PERMISSION = 2n;  // 0010

// Prüfen, ob Leseberechtigung gesetzt ist
console.log((permissions & READ_PERMISSION) > 0n); // true

// Prüfen, ob Schreibberechtigung gesetzt ist
console.log((permissions & WRITE_PERMISSION) > 0n); // false

// Schreibberechtigung hinzufügen
const newPermissions = permissions | WRITE_PERMISSION;
console.log(newPermissions); // 7n (was 0111 ist)
            

              
                Copy
              
            
          

Überlegungen zur Performance

Obwohl BigInt unglaublich leistungsfähig ist, ist es wichtig, seine Performance-Eigenschaften zu verstehen:

• Number vs. BigInt: Für Ganzzahlen innerhalb des sicheren Bereichs sind Standard-Number-Operationen deutlich schneller. Das liegt daran, dass sie oft direkt auf Maschineninstruktionen abgebildet werden können, die von der CPU des Computers verarbeitet werden. BigInt-Operationen, die eine beliebige Größe haben, erfordern komplexere softwarebasierte Algorithmen.
• BigInt vs. Bibliotheken: Natives BigInt ist im Allgemeinen viel schneller als JavaScript-basierte Bibliotheken für große Zahlen. Die Implementierung ist Teil der JavaScript-Engine (wie V8 oder SpiderMonkey) und ist in einer Low-Level-Sprache wie C++ geschrieben, was ihr einen erheblichen Leistungsvorteil verschafft.

Die goldene Regel: Verwenden Sie Number für alle numerischen Berechnungen, es sei denn, Sie haben einen bestimmten Grund zu der Annahme, dass die Werte Number.MAX_SAFE_INTEGER überschreiten könnten. Verwenden Sie BigInt, wenn Sie seine Fähigkeiten benötigen, nicht als Standardersatz für alle Zahlen.

Browser- und Umgebungskompatibilität

BigInt ist ein modernes JavaScript-Feature, aber seine Unterstützung ist mittlerweile im globalen Ökosystem weit verbreitet.

• Web-Browser: Wird in allen wichtigen modernen Browsern unterstützt (Chrome 67+, Firefox 68+, Safari 14+, Edge 79+).
• Node.js: Wird seit Version 10.4.0 unterstützt.

Für Projekte, die sehr alte Umgebungen unterstützen müssen, kann die Transpilierung mit Werkzeugen wie Babel eine Option sein, was jedoch mit einem Performance-Nachteil verbunden ist. Angesichts der breiten Unterstützung heutzutage können die meisten neuen Projekte BigInt bedenkenlos nativ verwenden.

Fazit und Best Practices

BigInt ist eine leistungsstarke und wesentliche Ergänzung der JavaScript-Sprache. Es bietet eine native, effiziente und ergonomische Lösung für das langjährige Problem der Arithmetik mit großen Ganzzahlen und ermöglicht die Erstellung einer neuen Klasse von Anwendungen mit JavaScript, von der Kryptografie bis zur hochpräzisen Datenverarbeitung.

Um es effektiv zu nutzen und häufige Fallstricke zu vermeiden, beachten Sie diese Best Practices:

1. Verwenden Sie das `n`-Suffix: Bevorzugen Sie die Literalsyntax `123n` zur Erstellung von BigInts. Sie ist klar, prägnant und vermeidet potenziellen Präzisionsverlust bei der Erstellung.
2. Mischen Sie keine Typen: Denken Sie daran, dass Sie BigInt und Number nicht in arithmetischen Operationen mischen können. Seien Sie explizit bei Ihren Konvertierungen: `BigInt()` oder `Number()`.
3. Priorisieren Sie Präzision: Bevorzugen Sie bei der Konvertierung zwischen den Typen immer die Umwandlung einer `Number` in ein `BigInt`, um versehentlichen Präzisionsverlust zu vermeiden.
4. Verwenden Sie strikte Gleichheit: Verwenden Sie `===` anstelle von `==` für Vergleiche, um verwirrendes Verhalten durch Typumwandlung zu vermeiden.
5. Behandeln Sie die JSON-Serialisierung: Planen Sie die Serialisierung von BigInts. Verwenden Sie eine benutzerdefinierte `replacer`-Funktion in `JSON.stringify` für eine sichere, nicht-globale Lösung.
6. Wählen Sie das richtige Werkzeug: Verwenden Sie Number für allgemeine mathematische Berechnungen innerhalb des sicheren Ganzzahlbereichs für eine bessere Performance. Greifen Sie nur dann auf `BigInt` zurück, wenn Sie dessen Fähigkeiten zur beliebigen Präzision wirklich benötigen.

Indem Sie BigInt annehmen und seine Regeln verstehen, können Sie robustere, genauere und leistungsfähigere JavaScript-Anwendungen schreiben, die in der Lage sind, numerische Herausforderungen jeder Größenordnung zu bewältigen.