Méthodes Numériques en JavaScript : La Puissance de Gérer Vos Valeurs ⚡️

Ah, JavaScript… À la fois ami fidèle et petit farceur.
Tu veux travailler avec des nombres, mais JS te regarde parfois comme ceci :

“Hmm… ce nombre est un peu gros, voyons ce que je vais faire.” 😅

Dans cet article, tu apprendras toutes les méthodes importantes, astuces et pièges liés aux nombres en JS, sans t’ennuyer.

1️⃣ Les Nombres en JavaScript : Amis ou Ennemi ?

JavaScript a un seul type de nombre :

Number

Mais Number est un peu complexe :

• Entiers, décimaux, négatifs → tout dans le même sac
• Respecte la norme IEEE 754
• Pour les grands nombres, les calculs peuvent être approximatifs

Petite astuce des floats

console.log(0.1 + 0.2); 
// 0.30000000000000004 😱

😂 Ce n’est pas 0.3 comme prévu !
Raison : JS stocke les nombres en binaire, et certaines représentations comme 0.1 + 0.2 ne sont pas exactes.

💡 Astuce : Pour des calculs financiers ou scientifiques précis, utilise des fonctions d’arrondi.

2️⃣ Astuces d’Arrondi : Approximatif mais Contrôlé 🤓

Problème :
0.1 + 0.2 = 0.30000000000000004

Solution : notation exponentielle et Math.round :

function roundTo(value, decimals) {
  return Number(Math.round(value + 'e' + decimals) + 'e-' + decimals);
}

console.log(roundTo(0.1 + 0.2, 2)); 
// 0.3 ✔️

Explication :

• 'e' + decimals → JS : “Décale la virgule pour arrondir”
• Math.round() → arrondi classique
• 'e-' + decimals → remet la virgule à sa place initiale

💡 Astuce : Dans les calculs financiers ou scientifiques, cette technique est salvatrice.

3️⃣ BigInt : Travailler en Toute Sécurité avec les Grands Nombres 💪

Number ne peut pas représenter correctement les très grands nombres :

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

Si on dépasse :

console.log(9007199254740991 + 1);
// 9007199254740992
console.log(9007199254740991 + 2);
// 9007199254740992 😱

Deux nombres différents → même résultat !
Les bits ne suffisent plus pour les grands nombres.

Solution : BigInt

const big = 9007199254740991n;
console.log(big + 2n);
// 9007199254740993n

Explication :

• Le suffixe n → JS : “Je suis un BigInt”
• Pas de perte de précision
• Ton prof de maths serait fier 😄

💡 Astuce : Utilise BigInt pour les très grands ID, les valeurs blockchain ou les totaux financiers.

4️⃣ L’Objet Math : Puissant mais Sélectif ⚡️

Math est ton ami pour les opérations mathématiques :

console.log(Math.sqrt(16)); 
// 4 ✔️
console.log(Math.sin(Math.PI / 2)); 
// 1 ✔️
console.log(Math.pow(2, 10)); 
// 1024 ✔️

Mais attention : il ne fonctionne pas avec BigInt

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

💡 Astuce : Convertis BigInt en Number avant :

const big = 16n;
console.log(Math.sqrt(Number(big))); 
// 4 ✔️

5️⃣ Tableaux et Map/Reduce : Les Nombres en Mode Turbo 💥

Les méthodes numériques nécessitent souvent de travailler avec tableaux et matrices.
JavaScript propose de super outils : map, reduce, filter.

Calcul de la moyenne

const numbers = [10, 20, 30, 40];
const avg = numbers.reduce((a, b) => a + b, 0) / numbers.length;
console.log(avg); 
// 25

Explication :

• reduce → additionne tous les éléments
• / numbers.length → divise par le nombre d’éléments pour obtenir la moyenne

💡 Astuce : Les arrow functions rendent le code plus lisible et rapide.

6️⃣ Number vs BigInt : Le Grand Piège ⚠️

Number et BigInt ne peuvent pas être combinés :

10n + 5; 
// TypeError ❌

Correct :

10n + 5n; 
10n + BigInt(5);

💡 Règle : Utilise le même type tout au long des calculs pour éviter les surprises.

7️⃣ Division : Le Petit Défi de BigInt 😅

BigInt est un entier, donc les divisions coupent la partie décimale :

10n / 3n; 
// 3n

Si tu veux un résultat décimal :

Number(10n) / 3;
// 3.3333333333333335

💡 Astuce : Attention à la précision lors de divisions avec de grands nombres.

8️⃣ Comparaisons : Attention aux Types

10n > 5; 
// true

Ça marche, JS compare la taille.

Mais :

10n === 10; 
// false ❌

• Les types sont différents → === retourne false
• 10n == 10 → true (mais ce n’est pas sûr, equality lâche)

💡 Astuce : Utilise === pour éviter les mauvaises surprises.

9️⃣ JSON et BigInt : Un Peu de Magie 😎

JSON.stringify({value: 10n}); 
// TypeError ❌

Solution :

JSON.stringify({value: 10n.toString()}); 
// '{"value":"10"}' ✔️

📌 Note : Pour API ou base de données, convertis en string puis reconvertis si nécessaire avec BigInt().

🔟 Exemples Concrets de BigInt

• Finance :

const totalMoney = 999999999999999999n;

• Cryptographie :

const privateKey = BigInt("0x123456789ABCDEF");

• Grands IDs / Blockchain :

const userId = 987654321987654321n;

💡 Astuce : La précision est essentielle, BigInt est ton allié.

1️⃣1️⃣ Performance 🚦

• BigInt → puissant mais un peu lent 🐢
• Number → rapide et suffisant pour les petits calculs ⚡️

💡 Astuce : N’utilise BigInt que pour les nombres vraiment grands.

1️⃣2️⃣ Astuces Bonus : Petits Trésors 💎

• Les méthodes Math → pas avec BigInt
• parseInt / parseFloat → pas pour BigInt
• Littéraux binaires / hexadécimaux → ok avec BigInt

const bin = 0b1010101010n; // binaire BigInt
const hex = 0xDEADBEEFn;   // hexadécimal BigInt

• Pour un code plus lisible, crée tes helper functions.

🎯 Résumé

• Number → rapide mais limité
• BigInt → précis mais plus lent
• Ne mélange pas ❌
• Grand nombre → BigInt ✅
• Floating point → arrondir ou helper functions
• Tableaux et matrices → map/reduce pratique
• JSON → convertir en string

Dernier conseil : “Fais attention aux nombres en JS, mais avec les bons outils, chaque nombre est ton serviteur !” 😄