JavaScript BigInt

Einführung in JavaScript BigInt

BigInt ist ein eingebauter JavaScript-Primitivtyp, der ganze Zahlen beliebiger Größe darstellt — also Ganzzahlen, die weit über das hinausgehen, was der reguläre Number-Typ sicher speichern kann. Diese Anleitung erklärt, warum BigInt existiert, wie man ihn erstellt und verwendet, wo er glänzt (Finanzen, Kryptografie, großskalige Berechnungen) und welche Fallstricke es zu beachten gilt.

Warum BigInt existiert

Der Number-Typ in JavaScript ist ein 64-Bit-Gleitkommawert. Er kann Ganzzahlen nur bis zu Number.MAX_SAFE_INTEGER exakt darstellen, nämlich 2^53 - 1 (9007199254740991). Darüber hinaus verliert normale Arithmetik stillschweigend an Präzision:

javascript— editable

Wann immer exakte Ganzzahlen größer als dieser Wert benötigt werden — IDs aus einer Datenbank, Währungsbeträge in der kleinsten Einheit, kryptografische Schlüssel, Fakultäten — ist BigInt die richtige Wahl.

BigInt in JavaScript verstehen

Ein BigInt ist ein eigenständiger Primitivtyp, der sich von Number unterscheidet. Der typeof-Operator gibt "bigint" zurück, und er hat eigene Rechenregeln.

Syntax und Erstellung

Ein BigInt wird erstellt, indem man n an ein ganzzahliges Literal anhängt oder die Funktion BigInt() mit einer Zahl oder einem string aufruft.

javascript— editable

Die string-Form sollte verwendet werden, wenn der Wert aus einer Eingabe stammt oder was ein numerisches Literal sicher ausdrücken kann übersteigt. Das Übergeben einer Nicht-Ganzzahl (z. B. BigInt(1.5)) löst einen RangeError aus.

Grundlegende Operationen mit BigInt

BigInt unterstützt dieselben arithmetischen Operatoren wie Number, aber beide Operanden müssen vom Typ BigInt sein. Division wird gegen null abgeschnitten — es gibt keinen Bruchteil.

javascript— editable

first / second ergibt 2n, nicht 2.5 — die BigInt-Division verwirft den Rest, anstatt einen Bruch zu erzeugen.

BigInt und Number vergleichen

Obwohl sie unterschiedliche Typen sind, können BigInt und Number mit relationalen Operatoren und dem losen Gleichheitsoperator == verglichen werden. Nur das strikte Gleichheitszeichen === unterscheidet die Typen, da es auch den Typ prüft.

javascript— editable

Weitere Informationen dazu, wie sich == und === im Allgemeinen unterscheiden, finden sich unter Vergleichsoperatoren.

Einschränkungen und Typkonvertierung

Obwohl BigInt leistungsfähig ist, hat er im Vergleich zum Standard-Number-Typ bestimmte Einschränkungen:

Keine implizite Umwandlung bei Arithmetik: Man kann einen BigInt und einen Number nicht direkt addieren, multiplizieren usw. — das löst einen TypeError aus. Zuerst eine Seite konvertieren.
Math-Funktionen: Standard-Math-Methoden (z. B. Math.sqrt(), Math.floor()) akzeptieren keine BigInt-Argumente und lösen einen Fehler aus.
Kein unäres Plus: +10n löst einen Fehler aus — stattdessen Number(10n) verwenden.
JSON: JSON.stringify kann einen BigInt nicht serialisieren und löst einen TypeError aus; zunächst manuell in einen string umwandeln.
Explizite Konvertierung: Zwischen den Typen mit Number(bigint) oder BigInt(number) konvertieren. Die Umwandlung in Number kann bei sehr großen Werten Präzision verlieren.

javascript— editable

Praktische Anwendungen von BigInt

Die Fähigkeit von BigInt, große Zahlen präzise zu verarbeiten, macht ihn in Finanzberechnungen, Kryptografie und großskaligen Berechnungen unverzichtbar.

Finanzberechnungen

In Finanzanwendungen hilft BigInt, die Rundungsfehler zu vermeiden, die mit Gleitkommazahlen verbunden sind.

javascript— editable

Dieses Beispiel veranschaulicht den Einsatz von BigInt für hochpräzise Arithmetik in Finanzkontexten und stellt die Genauigkeit bei Transaktionen sicher.

Info

BigInt ist ein unverzichtbares Werkzeug in der Kryptografie und spielt eine entscheidende Rolle bei der Erzeugung großer Primzahlen. Diese Zahlen sind grundlegend für die Sicherheitsmechanismen von Verschlüsselungsalgorithmen und sorgen dafür, dass Daten wirksam geschützt werden.

Hochleistungsrechnen

Das folgende Beispiel demonstriert den Einsatz von BigInt bei der Matrizenmultiplikation für die großskalige Datenverarbeitung und stellt dabei Präzision und Effizienz sicher. Es wird eine vollständige Implementierung der Matrizenmultiplikationsfunktion mit BigInt gezeigt. Dabei werden Matrizen initialisiert, mit BigInt-Werten befüllt und anschließend multipliziert. Hier ist ein schrittweises Praxisbeispiel:

Schritt 1: Matrix initialisieren

Zunächst erstellen wir eine Funktion zur Initialisierung einer Matrix mit gegebenen Dimensionen und BigInt-Nullen.

function initializeMatrix(rows, cols) {
  let matrix = new Array(rows);
  for (let i = 0; i < rows; i++) {
    matrix[i] = new Array(cols).fill(0n);
  }
  return matrix;
}

Schritt 2: Matrizenmultiplikationsfunktion

Als Nächstes definieren wir die Funktion zur Durchführung der Matrizenmultiplikation. Beide Eingabematrizen müssen BigInt-Werte enthalten, und die Ergebnismatrix wird ebenfalls BigInt-Werte enthalten.

function multiplyMatrices(matrixA, matrixB) {
  if (matrixA[0].length !== matrixB.length) {
    throw new Error('Number of columns in Matrix A must equal number of rows in Matrix B');
  }

  let resultMatrix = initializeMatrix(matrixA.length, matrixB[0].length);

  for (let i = 0; i < matrixA.length; i++) {
    for (let j = 0; j < matrixB[0].length; j++) {
      let sum = 0n;
      for (let k = 0; k < matrixA[0].length; k++) {
        sum += matrixA[i][k] * matrixB[k][j];
      }
      resultMatrix[i][j] = sum;
    }
  }
  return resultMatrix;
}

Schritt 3: Beispielmatrizen und Multiplikation

Schließlich erstellen wir einige Beispielmatrizen und führen die Multiplikation durch. Die Matrizen sind mit BigInt-Werten gefüllt.

javascript— editable

// Function to initialize a matrix with zeros (BigInt format)
function initializeMatrix(rows, cols) {
  let matrix = new Array(rows);
  for (let i = 0; i < rows; i++) {
    matrix[i] = new Array(cols).fill(0n); // Fill with BigInt zero
  }
  return matrix;
}

// Function to multiply two matrices that contain BigInt values
function multiplyMatrices(matrixA, matrixB) {
  if (matrixA[0].length !== matrixB.length) {
    throw new Error('The number of columns in Matrix A must be equal to the number of rows in Matrix B.');
  }

let resultMatrix = initializeMatrix(matrixA.length, matrixB[0].length);

for (let i = 0; i < matrixA.length; i++) {
    for (let j = 0; j < matrixB[0].length; j++) {
      let sum = 0n; // Start sum at BigInt zero
      for (let k = 0; k < matrixA[0].length; k++) {
        sum += matrixA[i][k] * matrixB[k][j]; // Add product of corresponding elements
      }
      resultMatrix[i][j] = sum; // Assign sum to the current position in result matrix
    }
  }
  return resultMatrix;
}

// Example matrices filled with BigInt values
let matrixA = [
  [1n, 2n],
  [3n, 4n]
];

let matrixB = [
  [2n, 0n],
  [1n, 2n]
];

// Perform matrix multiplication
let result = multiplyMatrices(matrixA, matrixB);

// Output the matrices by converting BigInt values to strings
console.log('Matrix A:', matrixA.map(row => row.map(value => `${value}n`)));
console.log('Matrix B:', matrixB.map(row => row.map(value => `${value}n`)));
console.log('Result of Multiplication:', result.map(row => row.map(value => `${value}n`)));

Erläuterung der Ausgabe

Dieses Beispiel multipliziert zwei 2x2-Matrizen, die mit BigInts gefüllt sind. Die Ausgabe ist eine neue Matrix, in der jedes Element das Ergebnis der auf BigInt-Werte angewendeten Matrizenmultiplikationsregeln ist. So sieht die Multiplikation aus:

Result[0][0] = (1n * 2n) + (2n * 1n) = 2n + 2n = 4n
Result[0][1] = (1n * 0n) + (2n * 2n) = 0n + 4n = 4n
Result[1][0] = (3n * 2n) + (4n * 1n) = 6n + 4n = 10n
Result[1][1] = (3n * 0n) + (4n * 2n) = 0n + 8n = 8n

Diese Funktionalität zeigt, wie BigInt eingesetzt werden kann, um große Zahlen in komplexen Berechnungen wie der Matrizenmultiplikation zu verarbeiten und dabei Präzision und Leistung in JavaScript-Anwendungen sicherzustellen, die numerische Berechnungen im großen Maßstab erfordern.

Warnung

BigInt sollte bedacht eingesetzt werden, da er aufgrund seines höheren Speicher- und Verarbeitungsbedarfs im Vergleich zu Standardzahlen die Leistung beeinträchtigen kann. Er sollte nur dann verwendet werden, wenn es wirklich notwendig ist, sehr große Ganzzahlen zu verarbeiten.

Best Practices für die Verwendung von BigInt in JavaScript

Beim Einsatz von BigInt in JavaScript-Projekten sollten die folgenden Best Practices berücksichtigt werden, um Leistung und Wartbarkeit zu optimieren:

Konsistente Datentypen: Das Mischen von BigInt mit anderen numerischen Typen vermeiden. Die Konvertierung zwischen BigInt und Number kann zu Fehlern oder unerwartetem Verhalten führen. Sicherstellen, dass alle Operanden in Berechnungen bei Bedarf vom Typ BigInt sind.
Angemessener Anwendungsfall: BigInt nur dann einsetzen, wenn Zahlen außerhalb des sicheren Bereichs für Standard-JavaScript-Zahlen verarbeitet werden müssen. Ein übermäßiger Einsatz von BigInt kann zu Leistungseinbußen führen.
Speicherüberlegungen: Obwohl BigInt sehr große Zahlen verarbeiten kann, sollte der Speicherverbrauch in Anwendungen im Auge behalten werden, insbesondere in Umgebungen mit begrenzten Ressourcen.
Kompatibilitätsprüfung: Vor der Verwendung von BigInt die Kompatibilität mit der Ziel-JavaScript-Umgebung prüfen, da ältere Browser oder einige JavaScript-Engines ihn möglicherweise nicht unterstützen.
Effiziente Algorithmen: Bei Operationen mit BigInt, insbesondere in Schleifen oder rekursiven Funktionen, die Algorithmen optimieren, um Leistungseinbußen zu minimieren.

Polyfills für BigInt in JavaScript verstehen

Der BigInt-Typ in JavaScript ist unverzichtbar für die Verarbeitung sehr großer Ganzzahlen, wird jedoch nicht in allen Umgebungen unterstützt. Um die Kompatibilität in verschiedenen Browsern und JavaScript-Engines, insbesondere älteren, sicherzustellen, kann das Polyfilling von BigInt ein praktischer Ansatz sein.

Was ist Polyfilling?

Polyfilling ist eine Technik, die verwendet wird, um Funktionen in Webbrowsern zu implementieren, die diese Funktionen nicht nativ unterstützen. Dabei wird ein Skript eingebunden, das die fehlende Funktionalität zur JavaScript-Umgebung des Browsers hinzufügt, sodass Entwickler moderne Funktionen nutzen können, ohne darauf warten zu müssen, dass alle Benutzer zu Browsern wechseln, die diese Funktionen unterstützen.

Polyfilling von BigInt

Da BigInt eine relativ neue Ergänzung zu JavaScript ist, wird er nicht von allen Umgebungen unterstützt. Polyfilling ermöglicht die Verwendung von BigInt in diesen nicht unterstützten Umgebungen, indem seine Funktionalität simuliert wird. Dies kann für Anwendungen entscheidend sein, die hochpräzise Berechnungen in Umgebungen erfordern, in denen ein Update auf die neueste Browserversion nicht möglich ist.

Implementierung eines BigInt-Polyfills

Die Implementierung eines BigInt-Polyfills umfasst das Erstellen oder Einbinden einer Bibliothek, die das BigInt-Verhalten nachahmt. Hier ist eine einfache konzeptionelle Demonstration, wie ein Polyfill-Wrapper strukturiert sein könnte:

// Conceptual demonstration only. A true BigInt polyfill is complex and impractical.
// This example uses Number conversion internally for simplicity and is not suitable 
// for production large-integer handling.
if (typeof BigInt === "undefined") {
    window.BigInt = function(value) {
        return {
            value: value,
            toString: function() { return value + "n"; },
            add: function(other) { return BigInt(Number(this.value) + Number(other.value)); },
            subtract: function(other) { return BigInt(Number(this.value) - Number(other.value)); }
        };
    };
}

Einschränkungen des Polyfilling von BigInt

Obwohl Polyfills Abwärtskompatibilität bieten können, sind sie kein perfekter Ersatz für native Implementierungen:

Leistung: Polyfills können nicht mit der Leistung nativer BigInt-Operationen mithalten, da sie in JavaScript implementiert sind und nicht in niedrigerem, von Browser-Herstellern optimiertem Code.
Komplexität: Das genaue Nachahmen aller Aspekte einer komplexen Funktion wie BigInt kann schwierig sein und zu Fehlern oder Inkonsistenzen führen.
Wartung: Das Aktuell-Halten des Polyfills bei Änderungen an der offiziellen BigInt-Spezifikation erfordert fortlaufende Wartung.

Info

Die Verwendung eines BigInt-Polyfills sollte erwogen werden, um die Kompatibilität in älteren Browsern zu gewährleisten, die BigInt nicht nativ unterstützen. Es ist jedoch zu beachten, dass Polyfills möglicherweise nicht die gleiche Leistung wie native Implementierungen bieten und als vorübergehende Lösung verwendet werden sollten, bis native Unterstützung allgemein verfügbar ist.

Fazit

BigInt ermöglicht es JavaScript, Ganzzahlen beliebiger Größe mit exakter Präzision darzustellen und schließt damit die Lücke, die durch die 53-Bit-Sicherheitsgrenze des Number-Typs entsteht. Er sollte immer dann eingesetzt werden, wenn eine Ganzzahl Number.MAX_SAFE_INTEGER überschreiten könnte — große Datenbank-IDs, Währungsbeträge in kleinsten Einheiten, kryptografische Werte und Berechnungen mit großen Zahlen. Für alltägliche Berechnungen, bei denen Brüche und Math-Methoden eine Rolle spielen, bleibt Number die richtige Wahl. Die zentrale Regel: Niemals BigInt und Number in der Arithmetik ohne explizite Konvertierung mischen.

Übungen

Übung

Was ist die korrekte Methode, einen BigInt in JavaScript zu erstellen?

Indem man ein 'n' an das Ende der Ganzzahl anhängt.Indem man ein 'b' an das Ende der Ganzzahl anhängt.Indem man die Funktion Big() verwendet.Indem man die Funktion BigInt() verwendet.

Einführung in JavaScript BigInt

Warum BigInt existiert

BigInt in JavaScript verstehen

Syntax und Erstellung

Grundlegende Operationen mit BigInt

BigInt und Number vergleichen

Einschränkungen und Typkonvertierung

Praktische Anwendungen von BigInt

Finanzberechnungen

Hochleistungsrechnen

Schritt 1: Matrix initialisieren

Schritt 2: Matrizenmultiplikationsfunktion

Schritt 3: Beispielmatrizen und Multiplikation

Erläuterung der Ausgabe

Best Practices für die Verwendung von BigInt in JavaScript

Polyfills für BigInt in JavaScript verstehen

Was ist Polyfilling?

Polyfilling von BigInt

Implementierung eines BigInt-Polyfills

Einschränkungen des Polyfilling von BigInt

Fazit

Verwandte Themen

Übungen