“BigInt en JavaScript : Représenter de Grands Nombres”

Représenter de Grands Nombres (Sans Perdre la Tête 🧠💥)

« JavaScript sait compter. »
Oui… jusqu’à ce qu’il commence à halluciner.
Et c’est exactement là que BigInt entre en scène 🎭

En JavaScript, les nombres sont rapides, pratiques…
mais ils ont une limite secrète.
Quand tu la dépasses, JavaScript continue de sourire… tout en te mentant 😅

Cette page est là pour t’apprendre :

• pourquoi BigInt existe
• comment l’utiliser correctement
• quand l’utiliser (et quand surtout pas)
• comment éviter les pièges classiques

Le Problème : les limites du type number ⚠️

En JavaScript, presque tous les nombres utilisent le type number.

let x = 42;

Simple, efficace, rapide.
Mais en coulisses, number utilise le format IEEE 754 (double précision).

La limite fatidique 🎯

console.log(Number.MAX_SAFE_INTEGER);
// 9007199254740991

👉 C’est le plus grand entier que JavaScript peut représenter sans erreur.

La Zone Rouge 🚨 (là où les bugs naissent)

let x = 9007199254740992;
console.log(x + 1 === x);
// true 😱

Que se passe-t-il ici ?

• JavaScript ne peut plus distinguer les nombres
• x + 1 est arrondi
• tu obtiens un bug sans message d’erreur

👉 Le pire type de bug.

La Solution : BigInt 🦸‍♂️

BigInt permet de représenter des entiers de taille illimitée.

Oui, illimitée.
Autant de chiffres que tu veux.
JavaScript ne panique plus 😌

Créer un BigInt 🧪

Méthode 1 : le suffixe n (la plus courante)

let big = 9007199254740992n;

🧠 Le n dit à JavaScript :

“Ce nombre est un BigInt, pas un number.”

Méthode 2 : avec le constructeur BigInt()

let big = BigInt("9007199254740992");

💡 Très utile quand :

• les données viennent d’une API
• les nombres sont stockés en string
• tu travailles avec des bases de données

Opérations avec BigInt 🔢

Bonne nouvelle :
BigInt supporte les opérations classiques.

let a = 10000000000000000n;
let b = 5n;

console.log(a + b); // addition
console.log(a - b); // soustraction
console.log(a * b); // multiplication
console.log(a / b); // division entière

⚠️ Attention à la division

10n / 3n
// 3n

👉 Pas de décimales.
BigInt = entiers uniquement.

BigInt ≠ Number (la règle d’or 🏆)

Tu ne peux PAS mélanger BigInt et number.

let a = 10n;
let b = 5;

console.log(a + b);
// ❌ TypeError

JavaScript dit :

“Choisis ton camp.”

Solutions possibles ✅

Convertir en BigInt

console.log(a + BigInt(b));
// 15n

Convertir en Number (si sûr)

console.log(Number(a) + b);
// 15

📌 Conseil pro
Si tu travailles avec de grands nombres → reste 100 % BigInt.

Comparaisons avec BigInt 🤔

Les comparaisons fonctionnent…

10n > 5      // true
10n < 20    // true

…mais attention à l’égalité

10n === 10  // false ❌
10n == 10   // true ⚠️

👉 Pourquoi ?

• === compare le type
• == fait une conversion implicite

📌 Bonne pratique
➡️ Utilise toujours ===

BigInt et Math ❌ (erreur classique)

Math.sqrt(16n);
// ❌ TypeError

Pourquoi ?

• Math travaille uniquement avec number
• BigInt est volontairement exclu

Que faire alors ?

👉 Implémenter toi-même les calculs
👉 Ou convertir temporairement (si possible)

Cas d’Usage Réels 🌍

1️⃣ Finance & banques 💰

let balance = 123456789123456789n;
let withdrawal = 50000000000000000n;

console.log(balance - withdrawal);

👉 Précision absolue.
👉 Zéro arrondi.
👉 Zéro surprise.

2️⃣ Identifiants & bases de données 🧾

let userId = 987654321987654321n;

Idéal pour :

• bases distribuées
• blockchains
• systèmes à grande échelle

3️⃣ Cryptomonnaies & blockchain 🔐

Les montants peuvent être énormes, la précision est vitale.

Quand NE PAS utiliser BigInt ❌

❌ Animations
❌ Calculs graphiques
❌ Nombres décimaux
❌ Calculs simples

👉 BigInt est plus lent que number.

Astuces & Bonnes Pratiques 🧠

✔️ Choisis BigInt dès le début du projet
✔️ Ne mélange jamais BigInt et number
✔️ Stocke les grands nombres en string → convertis ensuite
✔️ Utilise Number.isSafeInteger() pour décider

Résumé Express 📌

• number → rapide, limité
• BigInt → précis, sans limite
• n obligatoire
• Pas de Math
• Pas de décimales

Conclusion ☕

BigInt, c’est comme un coffre-fort :

🔒 lourd
🔒 solide
🔒 fiable

Si ton application manipule de grands nombres,
alors BigInt n’est pas un luxe — c’est une assurance.

Et maintenant…
JavaScript ne te mentira plus 😄