JavaScript - BigInt: Handling Really Big Numbers

Hallo zusammen, aspirierende Codierer! Heute machen wir uns auf eine aufregende Reise in die Welt der wirklich, wirklich großen Zahlen in JavaScript. Setzen Sie sich fest, denn wir werden den faszinierenden Bereich von BigInt erkunden!

Was ist BigInt?

Stellen Sie sich vor, Sie zählen Sterne am Nachthimmel. Sie zählen und zählen, aber plötzlich sagt Ihr Taschenrechner "Unendlich". Frustrierend, oder? Genau hier kommt BigInt zur Rettung!

BigInt ist eine besondere numerische Datenart in JavaScript, die ganzzahlige Werte beliebiger Länge darstellen kann. Im Gegensatz zu regulären Zahlen, die begrenzt sind, kann BigInt so große Zahlen handhaben, wie Ihre Vorstellungskraft (oder der Speicher Ihres Computers) es zulässt.

Warum brauchen wir BigInt?

In JavaScript werden reguläre Zahlen in 64 Bit gespeichert, was bedeutet, dass sie ein maximales sicheres ganzzahliges Wert von 9.007.199.254.740.991 haben. Das ist eine große Zahl, aber in der Welt der Informatik benötigen wir manchmal mégaschon größere Zahlen!

Sehen wir uns an, was passiert, wenn wir dieses Limit überschreiten:

console.log(9007199254740991n + 1n); // 9007199254740992n
console.log(9007199254740991n + 2n); // 9007199254740992n (Ups! Selbes Ergebnis)

Wie Sie sehen können, kann JavaScript Zahlen jenseits dieses Limits nicht genau darstellen. Genau hier kommt BigInt zum Tragen!

Deklaration und Initialisierung

Die Erstellung eines BigInts ist so einfach wie ein Pie. Sie haben zwei Möglichkeiten:

1. Anhängen von 'n' an das Ende einer Ganzzahl
2. Verwenden der BigInt()-Funktion

Lassen Sie es uns beide ausprobieren:

const bigNumber1 = 1234567890123456789012345678901234567890n;
const bigNumber2 = BigInt("9007199254740991");

console.log(bigNumber1); // 1234567890123456789012345678901234567890n
console.log(bigNumber2); // 9007199254740991n

Beachten Sie das 'n' am Ende? Das ist, wie JavaScript weiß, dass es ein BigInt ist!

Grundlegende Operationen

Nun, da wir unsere großen Zahlen haben, lassen Sie uns ein wenig Mathematik betreiben!

const a = 1234567890n;
const b = 9876543210n;

console.log(a + b);  // 11111111100n
console.log(a - b);  // -8641975320n
console.log(a * b);  // 12193263111263526900n
console.log(a / b);  // 0n (Ganzzahldivision)
console.log(a % b);  // 1234567890n

Denken Sie daran, BigInts sind immer ganzzahlige Werte. Bei der Division wird das Ergebnis auf den nächsten ganzzahligen Wert abgerundet.

Vergleiche

Den BigInts zu vergleichen ist genauso wie das mit regulären Zahlen:

console.log(5n > 4n);   // true
console.log(5n < 4n);   // false
console.log(5n === 5);  // false (verschiedene Typen)
console.log(5n == 5);   // true (Typzwangsumwandlung)

Beachten Sie die letzten beiden Zeilen. BigInts und reguläre Zahlen gelten als gleich, wenn man == verwendet, aber nicht, wenn man === verwendet. Dies liegt daran, dass === sowohl Wert- als auch Typengleichheit überprüft.

Umwandlungen

Manchmal müssen Sie zwischen BigInts und regulären Zahlen umwandeln. Hier ist, wie man das macht:

const bigNum = 123456789n;
const regularNum = Number(bigNum);

console.log(regularNum);  // 123456789

const backToBigInt = BigInt(regularNum);
console.log(backToBigInt);  // 123456789n

Seien Sie vorsichtig beim Umwandeln großer BigInts in reguläre Zahlen, da Sie möglicherweise die Genauigkeit verlieren!

Beispiele

Lassen Sie uns unser BigInt-Wissen mit einigen realen Weltbeispielen anwenden:

1. Berechnung von Fakultäten

function factorial(n) {
if (n === 0n) return 1n;
return n * factorial(n - 1n);
}

console.log(factorial(20n));  // 2432902008176640000n

Diese Funktion kann die Fakultäten viel größerer Zahlen berechnen als reguläre JavaScript-Zahlen!

2. Arbeit mit wirklich großen Primzahlen

function isPrime(n) {
if (n <= 1n) return false;
for (let i = 2n; i * i <= n; i++) {
if (n % i === 0n) return false;
}
return true;
}

const largeNumber = 2n ** 100n - 1n;
console.log(isPrime(largeNumber) ? "Prime" : "Not Prime");  // Not Prime

Diese Funktion kann die Primzahlstatus für Zahlen überprüfen, die weit über die Grenzen regulärer JavaScript-Zahlen hinausgehen!

Fehlerbehandlung mit BigInt

Beim Arbeiten mit BigInts gibt es ein paar Dinge zu beachten:

try {
const result = 1n + 1;  // Dies wird einen Fehler auslösen
} catch (error) {
console.log("Error:", error.message);  // Cannot mix BigInt and other types
}

try {
const result = Math.sqrt(4n);  // Dies wird ebenfalls einen Fehler auslösen
} catch (error) {
console.log("Error:", error.message);  // Cannot convert a BigInt value to a number
}

Denken Sie daran, BigInts können nur mit anderen BigInts für arithmetische Operationen verwendet werden, und viele Math-Funktionen unterstützen BigInts nicht.

BigInt-Methoden

Hier ist eine Tabelle der am häufigsten verwendeten BigInt-Methoden:

Methode	Beschreibung	Beispiel
BigInt()	Erzeugt einen BigInt-Wert	BigInt(123)
BigInt.asIntN()	Wickelt einen BigInt-Wert zu einem vorzeichenbehafteten Integer zwischen -2^(n-1) und 2^(n-1)-1	BigInt.asIntN(3, 5n) // 5n
BigInt.asUintN()	Wickelt einen BigInt-Wert zu einem unvorzeichenbehafteten Integer zwischen 0 und 2^n-1	BigInt.asUintN(3, 5n) // 5n
BigInt.prototype.toString()	Gibt eine Zeichenkettenrepräsentation eines BigInt-Werts zurück	(123n).toString() // "123"
BigInt.prototype.valueOf()	Gibt den primitiven Wert eines BigInt-Objekts zurück	Object(123n).valueOf() // 123n

Und das war's, Leute! Sie sind jetzt darauf vorbereitet, Zahlen zu handhaben, die größer als die Sterne am Himmel sind. Denken Sie daran, dass mit großer Macht große Verantwortung einhergeht - verwenden Sie Ihre BigInts weise!

Frohes Coden und mögen Ihre Zahlen immer so groß sein wie Ihre Träume!

Credits: Image by storyset