Apprends Nombres & Math

Types de nombres

En JavaScript, tous les nombres sont des valeurs à virgule flottante stockées au format IEEE 754 double précision 64 bits. Il n'existe pas de type entier séparé — 42 et 42.0 sont la même chose.

JavaScript possède plusieurs valeurs numériques spéciales :

javascript

console.log(Infinity);      // Infinity
console.log(-Infinity);     // -Infinity
console.log(1 / 0);         // Infinity
console.log(NaN);           // NaN (Not a Number)
console.log('hello' * 2);   // NaN

NaN est une valeur spéciale qui représente un résultat mathématique invalide ou non défini. Important : NaN n'est égal à rien, pas même à lui-même :

javascript

console.log(NaN === NaN); // false

Pour vérifier NaN, utilise Number.isNaN() (préféré) ou isNaN() :

javascript

Number.isNaN(NaN);       // true
Number.isNaN('hello');   // false (ne force PAS la conversion)
isNaN('hello');           // true (convertit en nombre d'abord — moins fiable)

Convertir des chaînes de caractères en nombres :

javascript

parseInt('42px');      // 42 (analyse jusqu'au premier non-chiffre)
parseFloat('3.14abc'); // 3.14
Number('42');          // 42 (strict — échoue sur les caractères en trop)
Number('42px');        // NaN

L'objet Math

L'objet Math fournit des constantes et fonctions mathématiques. Ce n'est pas un constructeur — tu utilises ses méthodes directement.

Méthodes d'arrondi :

javascript

Math.round(4.5);  // 5 (arrondit à l'entier le plus proche)
Math.round(4.4);  // 4
Math.floor(4.9);  // 4 (arrondit vers le BAS)
Math.ceil(4.1);   // 5 (arrondit vers le HAUT)
Math.trunc(4.9);  // 4 (supprime la partie décimale)
Math.trunc(-4.9); // -4

Min, max et valeur absolue :

javascript

Math.min(1, 5, 3);   // 1
Math.max(1, 5, 3);   // 5
Math.abs(-42);        // 42

Puissances et racines :

javascript

Math.pow(2, 8);  // 256 (2 puissance 8)
2 ** 8;          // 256 (opérateur d'exponentiation — même résultat)
Math.sqrt(144);  // 12

Nombres aléatoires :

Math.random() retourne un nombre à virgule flottante dans l'intervalle [0, 1) — de 0 (inclus) jusqu'à 1 (exclu).

javascript

Math.random();                          // ex. 0.7362...
Math.floor(Math.random() * 10);         // entier aléatoire 0–9
Math.floor(Math.random() * 10) + 1;     // entier aléatoire 1–10
Math.floor(Math.random() * (max - min + 1)) + min; // aléatoire dans un intervalle

Méthodes de nombre

Les nombres en JavaScript ont plusieurs méthodes utiles.

toFixed(digits) formate un nombre avec un nombre fixe de décimales. Elle retourne une chaîne de caractères :

javascript

const pi = 3.14159;
console.log(pi.toFixed(2));  // '3.14'
console.log(pi.toFixed(0));  // '3'
console.log(pi.toFixed(4));  // '3.1416' (arrondit)

toPrecision(digits) formate un nombre avec un nombre total spécifié de chiffres significatifs :

javascript

const num = 123.456;
console.log(num.toPrecision(5)); // '123.46'
console.log(num.toPrecision(2)); // '1.2e+2'

toString(radix) convertit un nombre en chaîne de caractères dans la base donnée :

javascript

const num = 255;
console.log(num.toString(16)); // 'ff' (hexadécimal)
console.log(num.toString(2));  // '11111111' (binaire)

Méthodes statiques sur Number :

javascript

Number.isInteger(42);     // true
Number.isInteger(42.5);   // false
Number.isFinite(42);      // true
Number.isFinite(Infinity); // false
Number.isFinite(NaN);     // false

Pièges des nombres à virgule flottante

L'une des choses les plus surprenantes en JavaScript (et dans la plupart des langages de programmation) est ceci :

javascript

console.log(0.1 + 0.2);          // 0.30000000000000004
console.log(0.1 + 0.2 === 0.3);  // false!

Pourquoi cela se produit-il ? Les nombres sont stockés en binaire (base 2). Tout comme 1/3 ne peut pas être exactement représenté en décimal (0.333...), des valeurs comme 0.1 et 0.2 ne peuvent pas être exactement représentées en binaire. Les minuscules erreurs d'arrondi s'accumulent.

Solutions de contournement :

Multiplier, opérer, puis diviser — travailler avec des entiers :

javascript

const result = (0.1 * 10 + 0.2 * 10) / 10; // 0.3

Utiliser toFixed() pour l'affichage :

javascript

const sum = 0.1 + 0.2;
console.log(sum.toFixed(2)); // '0.30'
console.log(Number(sum.toFixed(2))); // 0.3

Utiliser un epsilon pour les comparaisons :

javascript

const EPSILON = Number.EPSILON;
console.log(Math.abs(0.1 + 0.2 - 0.3) < EPSILON); // true

Ce n'est pas un bug JavaScript — c'est une propriété fondamentale de l'arithmétique à virgule flottante IEEE 754 utilisée par pratiquement tous les langages de programmation modernes.

Méthodes Math en action

html

<div id="output"></div>

<script>
  // Rounding
  const pi = Math.PI;
  const rounded = Math.round(pi);   // 3
  const floored = Math.floor(pi);   // 3
  const ceiled = Math.ceil(pi);     // 4
  const fixed = pi.toFixed(2);      // '3.14'

  // Random integer between 1 and 100
  const random = Math.floor(Math.random() * 100) + 1;

  // Powers
  const squared = Math.pow(7, 2);   // 49
  const cubeRoot = Math.cbrt(27);   // 3

  const output = document.getElementById('output');
  output.innerHTML = `
    <p>Math.PI: ${pi}</p>
    <p>Rounded: ${rounded} | Floor: ${floored} | Ceil: ${ceiled}</p>
    <p>Fixed (2 decimals): ${fixed}</p>
    <p>Random (1-100): ${random}</p>
    <p>7 squared: ${squared} | Cube root of 27: ${cubeRoot}</p>
  `;
</script>

Que retourne Math.floor(4.9) ?

Nombres & Math

Types de nombres

L'objet Math

Méthodes de nombre

Pièges des nombres à virgule flottante

Méthodes Math en action

Prêt à pratiquer ?