📝 Ce que vous apprendrez

• Ce qu'est BigInt en JavaScript
• Comment créer et travailler avec BigInt ?
• Différences entre BigInt et nombres ordinaires
• Cas d'utilisation de BigInt
• Exemples pratiques pour comprendre les opérations BigInt

🔍 Qu'est-ce que BigInt ?

BigInt est un objet intégré à JavaScript qui vous permet de travailler avec des entiers de précision arbitraire, c'est-à-dire des nombres qui sont trop grands ou trop petits pour être représentés par le type Number. Alors que le type Number de JavaScript ne peut gérer que des valeurs allant jusqu'à environ 2^53 - 1 (le plus grand entier sûr), BigInt vous permet de représenter et d'effectuer des opérations sur des nombres beaucoup plus grands sans perdre en précision.

Exemple :

let bigNumber = 1234567890123456789012345678901234567890n;
console.log(bigNumber);  // Output: 1234567890123456789012345678901234567890n

Notez le n à la fin du nombre, indiquant qu'il s'agit d'un BigInt.

🧑‍🍳 Création d'un BigInt

Vous pouvez créer un BigInt en JavaScript en ajoutant la lettre n à un entier ou en utilisant le constructeur BigInt().

1️⃣ Utilisation de n pour créer un BigInt

let bigIntValue = 9876543219876543210n;
console.log(bigIntValue);  // Output: 9876543219876543210n

2️⃣ Utilisation du constructeur BigInt().

let bigIntFromConstructor = BigInt("9876543219876543210");
console.log(bigIntFromConstructor);  // Output: 9876543219876543210n

Les deux méthodes créent une valeur BigInt. La différence est que BigInt() peut aussi être utilisé pour convertir des chaînes de caractères ou d'autres valeurs numériques en BigInt.

🧮 Opérations BigInt

Vous pouvez effectuer des opérations mathématiques sur les valeurs BigInt comme sur des nombres ordinaires, telles que l'addition, la soustraction, la multiplication et la division.

1️⃣ Addition et soustraction

let bigNum1 = 12345678901234567890n;
let bigNum2 = 98765432109876543210n;

let sum = bigNum1 + bigNum2;
let diff = bigNum2 - bigNum1;

console.log(sum);   // Output: 111111111011111111100n
console.log(diff);  // Output: 86419753208641975320n

2️⃣ Multiplication

let bigNum1 = 12345678901234567890n;
let bigNum2 = 98765432109876543210n;

let product = bigNum1 * bigNum2;
console.log(product);  // Output: 1219326311370217952274851956012610475690n

3️⃣ Division

La division BigInt tronque le résultat vers zéro (supprime la partie fractionnaire).

let bigNum1 = 12345678901234567890n;
let bigNum2 = 98765432109876543210n;

let quotient = bigNum2 / bigNum1;
console.log(quotient);  // Output: 8n

4️⃣ Modulo (Reste)

let bigNum1 = 12345678901234567890n;
let bigNum2 = 98765432109876543210n;

let remainder = bigNum2 % bigNum1;
console.log(remainder);  // Output: 86419753208641975320n

🛑 Limites de BigInt

Bien que BigInt soit utile pour manipuler les grands nombres entiers, il présente quelques limitations :

1️⃣ Opérations mixtes avec des nombres

Vous ne pouvez pas mélanger directement les types BigInt et Number dans les opérations. Par exemple, vous ne pouvez pas additionner un BigInt et un Number :

let bigIntValue = 12345678901234567890n;
let numberValue = 10;

let result = bigIntValue + numberValue;  // Error: Cannot mix BigInt and other types

Pour résoudre ce problème, vous devez d'abord convertir le Nombre en BigInt :

let result = bigIntValue + BigInt(numberValue);  // Correct
console.log(result);  // Output: 12345678901234567890n

2️⃣ Pas de support décimal

BigInt ne peut représenter que des nombres entiers et ne prend pas en charge les valeurs à virgule flottante ou les décimales.

let floatValue = 10.5;
let bigIntValue = BigInt(floatValue);  // Error: Cannot convert a non-integer value to BigInt

Pour traiter les décimales, vous devez utiliser les Nombres ordinaires ou d'autres méthodes de traitement de l'arithmétique à virgule flottante.

💡 Quand utiliser BigInt ?

BigInt est idéal pour les situations qui impliquent de très grands nombres entiers ou des situations où vous avez besoin d'une précision arbitraire. Voici quelques exemples :

• Applications cryptographiques
• Applications financières nécessitant des calculs de haute précision
• Traitement de données scientifiques volumineuses

Cependant, dans la plupart des scénarios quotidiens, le type Nombre intégré dans JavaScript est suffisant.

🧠 Recap

• BigInt vous permet de travailler avec des entiers au-delà des limites du type Number.
• Vous pouvez créer BigInt en utilisant le suffixe n ou le constructeur BigInt().
• Les opérations mathématiques sur les BigInt fonctionnent de la même manière que les nombres ordinaires, mais il n'est pas permis de mélanger directement les BigInt avec les Nombres.
• BigInt ne prend pas en charge les nombres à virgule flottante ou les décimales.