JavaScript BigInt-Arithmetik: Berechnungen mit großen Zahlen & Handhabung der Präzision

JavaScript verwendet standardmäßig den Datentyp Number, um numerische Werte darzustellen. Obwohl dies für viele Anwendungsfälle ausreichend ist, hat der Typ Number Einschränkungen bei der genauen Darstellung sehr großer Ganzzahlen aufgrund seines zugrunde liegenden Gleitkommaformats mit doppelter Genauigkeit (IEEE 754). Dies kann zu Präzisionsverlust und unerwarteten Ergebnissen führen, wenn mit Zahlen gearbeitet wird, die die maximale sichere Ganzzahl (Number.MAX_SAFE_INTEGER) überschreiten, welche 2⁵³ - 1 beträgt.

Hier kommt BigInt ins Spiel, ein in ES2020 eingeführter, integrierter JavaScript-Datentyp, der speziell zur Darstellung von Ganzzahlen beliebiger Länge entwickelt wurde. BigInt ermöglicht es Ihnen, arithmetische Operationen mit extrem großen Zahlen ohne Präzisionsverlust durchzuführen. Dies eröffnet Möglichkeiten für Berechnungen in Bereichen wie Kryptographie, wissenschaftliches Rechnen und Finanzanwendungen, in denen Genauigkeit von größter Bedeutung ist.

Was ist BigInt?

BigInt ist ein primitiver Datentyp, der ganze Zahlen darstellt, die größer sind, als der Typ Number genau handhaben kann. Im Gegensatz zu Number haben BigInts keine feste Größe, was bedeutet, dass sie wachsen können, um jede beliebige Ganzzahl aufzunehmen, begrenzt nur durch den verfügbaren Speicher.

BigInts erstellen

Es gibt zwei primäre Methoden, um BigInts in JavaScript zu erstellen:

• Anhängen von n an ein Ganzzahlliteral: Dies ist die einfachste Methode. Fügen Sie einfach das Suffix 'n' am Ende einer Zahl hinzu. Zum Beispiel: 12345678901234567890n.
• Verwendung des BigInt()-Konstruktors: Sie können den BigInt()-Konstruktor verwenden, um eine Zahl (Number), einen String oder ein anderes BigInt in einen BigInt-Wert umzuwandeln. Zum Beispiel: BigInt(12345) oder BigInt("12345678901234567890"). Beachten Sie, dass die Umwandlung einer Gleitkommazahl in ein BigInt den Dezimalteil abschneidet; es wird nicht gerundet.

Beispiel:

            
const largeNumberLiteral = 9007199254740991n; // Verwendung des 'n'-Suffixes
const largeNumberConstructor = BigInt(9007199254740991); // Verwendung des BigInt()-Konstruktors
const stringBasedBigInt = BigInt("1234567890123456789012345"); // Erstellung aus einem String

console.log(largeNumberLiteral); // Ausgabe: 9007199254740991n
console.log(largeNumberConstructor); // Ausgabe: 9007199254740991n
console.log(stringBasedBigInt); // Ausgabe: 1234567890123456789012345n

            

              
                Copy
              
            
          

Arithmetische Operationen mit BigInt

BigInts unterstützen standardmäßige arithmetische Operationen wie Addition, Subtraktion, Multiplikation, Division und Potenzierung. Es gibt jedoch wichtige Aspekte zu beachten:

• Gemischte Arithmetik ist nicht erlaubt: Sie können arithmetische Operationen nicht direkt zwischen BigInts und Numbers durchführen. Sie müssen Numbers vor der Berechnung explizit mit dem BigInt()-Konstruktor in BigInts umwandeln. Dies ist eine Designentscheidung, um unbeabsichtigten Präzisionsverlust zu verhindern.
• Verhalten bei der Division: Die Division zwischen BigInts wird in Richtung Null abgeschnitten, wobei jeder Bruchteil verworfen wird. Es gibt kein Äquivalent zum Modulo-Operator (%), der einen gebrochenen Rest zurückgibt.
• Vergleichsoperatoren: Standard-Vergleichsoperatoren (==, ===, <, >, <=, >=) funktionieren zwischen BigInts und Numbers. Beachten Sie, dass == eine Typumwandlung durchführt, während === false zurückgibt, wenn Sie ein BigInt mit einer Number vergleichen.

Beispiele für arithmetische Operationen

            
const a = 10n;
const b = 5n;
const c = 2;

console.log(a + b); // Ausgabe: 15n (BigInt + BigInt)
console.log(a - b); // Ausgabe: 5n (BigInt - BigInt)
console.log(a * b); // Ausgabe: 50n (BigInt * BigInt)
console.log(a / b); // Ausgabe: 2n (BigInt / BigInt, Abschneiden in Richtung Null)
console.log(a ** b); // Ausgabe: 100000n (BigInt-Potenzierung)

//console.log(a + c); // Dies wirft einen TypeError: Kann BigInt nicht mit anderen Typen mischen, verwenden Sie explizite Konvertierungen
console.log(a + BigInt(c)); // Ausgabe: 12n (BigInt + zu BigInt konvertierte Number)
console.log(a > BigInt(c)); // Ausgabe: true (BigInt verglichen mit zu BigInt konvertierter Number)

console.log(10n == 10); // Ausgabe: true
console.log(10n === 10); // Ausgabe: false

            

              
                Copy
              
            
          

Der Modulo-Operator (%) und BigInts

Der Modulo-Operator (%) funktioniert nicht direkt mit BigInts. Um ein ähnliches Ergebnis zu erzielen, können Sie den folgenden Ansatz verwenden:

            
function bigIntModulo(dividend, divisor) {
  return dividend - (divisor * (dividend / divisor));
}

const dividend = 25n;
const divisor = 7n;

console.log(bigIntModulo(dividend, divisor)); // Ausgabe: 4n

            

              
                Copy
              
            
          

Einschränkungen von BigInt

Obwohl BigInt erhebliche Vorteile bietet, ist es wichtig, sich seiner Einschränkungen bewusst zu sein:

• Keine Dezimaldarstellung: BigInts können nur ganze Zahlen darstellen. Sie können nicht für Gleitkomma-Arithmetik oder die Darstellung von Zahlen mit Dezimalstellen verwendet werden. Für hochpräzise Dezimalberechnungen sollten Sie Bibliotheken wie decimal.js oder big.js in Betracht ziehen.
• Mischen mit Numbers: Wie bereits erwähnt, sind direkte arithmetische Operationen zwischen BigInts und Numbers nicht erlaubt. Sie müssen Numbers explizit in BigInts umwandeln, was die Komplexität Ihres Codes erhöhen kann.
• Leistung: BigInt-Operationen können langsamer sein als Standard-Number-Operationen, insbesondere bei sehr großen Zahlen. Dies liegt daran, dass die BigInt-Arithmetik komplexere Algorithmen und eine aufwendigere Speicherverwaltung erfordert. Berücksichtigen Sie die Leistungsauswirkungen bei der Verwendung von BigInt in leistungskritischen Anwendungen.
• JSON-Serialisierung: BigInt-Werte können nicht direkt mit JSON.stringify() serialisiert werden. Der Versuch, ein BigInt direkt zu serialisieren, führt zu einem TypeError. Sie müssen das BigInt vor der Serialisierung in einen String umwandeln.

Workaround für die JSON-Serialisierung

Um BigInt-Werte in JSON zu serialisieren, können Sie die toJSON-Methode verwenden oder sie explizit in Strings umwandeln:

            
const bigIntValue = 12345678901234567890n;

// Methode 1: Verwendung der toJSON-Methode
BigInt.prototype.toJSON = function() { return this.toString() };

const obj1 = { value: bigIntValue };
const jsonString1 = JSON.stringify(obj1);
console.log(jsonString1); // Ausgabe: {"value":"12345678901234567890"}

// Methode 2: Explizite Umwandlung in einen String
const obj2 = { value: bigIntValue.toString() };
const jsonString2 = JSON.stringify(obj2);
console.log(jsonString2); // Ausgabe: {"value":"12345678901234567890"}

//Beim Parsen müssen Sie es wieder in ein BigInt umwandeln.
const parsedObj = JSON.parse(jsonString2, (key, value) => {
  if (typeof value === 'string' && /^[0-9]+$/.test(value)) {
    try {
      return BigInt(value);
    } catch (e) {
      return value; // Kein BigInt-String
    }
  }
  return value;
});

console.log(parsedObj.value); //Ausgabe: 12345678901234567890n
console.log(typeof parsedObj.value); //Ausgabe: bigint


            

              
                Copy
              
            
          

Anwendungsfälle aus der Praxis für BigInt

BigInts sind in Szenarien wertvoll, in denen präzise Berechnungen mit großen Ganzzahlen entscheidend sind. Hier sind einige prominente Anwendungsfälle:

• Kryptographie: Kryptographische Algorithmen beinhalten oft Berechnungen mit extrem großen Primzahlen. BigInts sind für die genaue Implementierung dieser Algorithmen unerlässlich. Beispiele hierfür sind die RSA-Verschlüsselung, der Diffie-Hellman-Schlüsselaustausch und die Elliptische-Kurven-Kryptographie. Beispielsweise erfordert das Generieren großer Primzahlen für RSA die Überprüfung der Primalität sehr großer Zahlen, eine Aufgabe, bei der BigInt entscheidend ist.
• Finanzanwendungen: Die Handhabung großer Geldbeträge oder die Durchführung komplexer Finanzberechnungen erfordert hohe Präzision, um Rundungsfehler zu vermeiden. BigInts können eine genaue Darstellung von Geldwerten sicherstellen, insbesondere in Systemen, die mit internationalen Währungen und Transaktionen arbeiten. Stellen Sie sich vor, Sie berechnen die Zinsen für einen sehr großen Kredit über einen langen Zeitraum; BigInt kann die notwendige Präzision beibehalten.
• Wissenschaftliches Rechnen: Wissenschaftliche Simulationen und Berechnungen beinhalten oft den Umgang mit sehr großen oder sehr kleinen Zahlen. BigInts können verwendet werden, um große Ganzzahlwerte in wissenschaftlichen Modellen und Simulationen darzustellen. Beispiele sind die Berechnung von Fakultäten, die Simulation von Teilcheninteraktionen und die Modellierung astronomischer Phänomene.
• Blockchain-Technologie: Blockchain-Transaktionen und kryptographische Hash-Funktionen stützen sich stark auf Arithmetik mit großen Ganzzahlen. BigInts werden verwendet, um Transaktionsbeträge, Blockhöhen und andere kritische Datenelemente in Blockchain-Systemen darzustellen. Denken Sie an die Ethereum-Blockchain, wo Gaspreise und Transaktionsgebühren oft als sehr große Ganzzahlen ausgedrückt werden.
• Hochpräzise Berechnungen: Jede Anwendung, die eine exakte Ganzzahldarstellung jenseits der Grenzen des Number-Typs erfordert, kann von BigInt profitieren. Dies schließt Anwendungen in Bereichen wie Zahlentheorie, kombinatorische Mathematik und Spieleentwicklung ein.

BigInt und Browserkompatibilität

BigInt ist eine relativ neue Ergänzung zu JavaScript, daher ist es wichtig, die Browserkompatibilität zu berücksichtigen, wenn Sie es in Ihren Projekten verwenden. Die meisten modernen Browser unterstützen BigInt, einschließlich Chrome, Firefox, Safari und Edge. Ältere Browser bieten jedoch möglicherweise keine native Unterstützung. Sie können die Kompatibilität mit Ressourcen wie caniuse.com überprüfen.

Für Projekte, die auf ältere Browser abzielen, könnten Sie die Verwendung eines Polyfills oder eines Transpilers wie Babel in Erwägung ziehen, um BigInt-Unterstützung bereitzustellen. Ein Polyfill bietet eine JavaScript-Implementierung von BigInt für Browser, die es nicht nativ unterstützen, während ein Transpiler Ihren Code mit BigInts in äquivalenten Code umwandelt, der in älteren Umgebungen funktioniert.

Best Practices für die Verwendung von BigInt

Um BigInts effektiv in Ihren JavaScript-Projekten zu nutzen, sollten Sie die folgenden Best Practices beachten:

• Verwenden Sie BigInt nur bei Bedarf: Vermeiden Sie die Verwendung von BigInt, es sei denn, Sie müssen speziell Ganzzahlen darstellen, die größer als Number.MAX_SAFE_INTEGER sind, oder hohe Präzision benötigen. Die unnötige Verwendung von BigInt kann zu Leistungseinbußen führen.
• Wandeln Sie Numbers explizit in BigInts um: Wandeln Sie Numbers immer explizit mit dem BigInt()-Konstruktor in BigInts um, bevor Sie arithmetische Operationen durchführen. Dies hilft, versehentliche Typfehler zu vermeiden und stellt sicher, dass Ihre Berechnungen korrekt durchgeführt werden.
• Achten Sie auf das Divisionsverhalten: Denken Sie daran, dass die Division zwischen BigInts in Richtung Null abschneidet. Wenn Sie mit Resten umgehen müssen, verwenden Sie die bigIntModulo-Funktion oder einen ähnlichen Ansatz.
• Berücksichtigen Sie Leistungsauswirkungen: BigInt-Operationen können langsamer sein als Number-Operationen, insbesondere bei sehr großen Zahlen. Testen Sie Ihren Code gründlich, um potenzielle Leistungsengpässe zu identifizieren und Ihre BigInt-Nutzung zu optimieren.
• Handhaben Sie die JSON-Serialisierung sorgfältig: Denken Sie daran, BigInt-Werte vor der Serialisierung in JSON in Strings umzuwandeln und sie beim Parsen des JSON wieder in BigInt zurückzuverwandeln.
• Verwenden Sie klare und beschreibende Variablennamen: Verwenden Sie bei der Arbeit mit BigInts Variablennamen, die deutlich darauf hinweisen, dass der Wert ein BigInt ist. Dies kann die Lesbarkeit des Codes verbessern und Verwirrung vermeiden. Verwenden Sie beispielsweise Namen wie largeValueBigInt oder userIdBigInt.
• Dokumentieren Sie Ihren Code: Fügen Sie Ihrem Code Kommentare hinzu, um zu erklären, warum Sie BigInts verwenden, und um potenziell verwirrende Aspekte Ihrer BigInt-Berechnungen zu klären.

Fazit

Der BigInt-Datentyp von JavaScript bietet eine leistungsstarke Lösung für die präzise Handhabung großer Ganzzahlberechnungen. Indem Sie seine Funktionen, Einschränkungen und Best Practices verstehen, können Sie BigInts effektiv in einer Vielzahl von Anwendungen einsetzen, von Kryptographie und Finanzmodellierung bis hin zu wissenschaftlichem Rechnen und Blockchain-Technologie. Obwohl es Leistungs- und Kompatibilitätsüberlegungen gibt, überwiegen die Vorteile der genauen Darstellung großer Ganzzahlen oft die Nachteile, insbesondere in Situationen, in denen Präzision von größter Bedeutung ist. Denken Sie immer daran, explizit zwischen den Typen Number und BigInt zu konvertieren und die JSON-Serialisierung sorgfältig zu handhaben, um unerwartete Fehler zu vermeiden. Da sich JavaScript weiterentwickelt, wird BigInt zweifellos eine immer wichtigere Rolle dabei spielen, Entwicklern zu ermöglichen, komplexe numerische Herausforderungen mit Zuversicht und Genauigkeit zu meistern.