Les nombres JavaScript

Introduction aux nombres JavaScript

JavaScript est un langage dynamique, et la façon dont il stocke les nombres a des conséquences directes sur le code quotidien : pourquoi 0.1 + 0.2 n'est pas exactement 0.3, pourquoi les très grands entiers perdent en précision, et comment arrondir, formater et analyser les valeurs en toute sécurité. Cette page couvre le type number standard, les valeurs spéciales Infinity et NaN, les fonctions de conversion, ainsi que les pièges qui font trébucher la plupart des développeurs — avec des exemples exécutables modifiables.

Comprendre les types de nombres

JavaScript possède exactement deux types de données numériques :

• number — le type courant. Il utilise le format IEEE-754 64 bits (« virgule flottante double précision »), de sorte que le même type contient à la fois des entiers comme 42 et des décimaux comme 3.14. Il n'existe pas de int ou float séparé.
• BigInt — pour les entiers dépassant la plage sûre de number (plus de détails ci-dessous). Un littéral BigInt se termine par n, par exemple 9007199254740993n.

On peut les distinguer avec typeof :

Écrire des nombres en JavaScript

Au-delà des simples chiffres, JavaScript offre quelques commodités pour la lisibilité :

let billion = 1e9;        // scientific notation → 1000000000
let ms = 1e-6;            // 0.000001 (one microsecond)
let big = 1_000_000;      // underscores as visual separators (ES2021)

1e9 signifie « 1 suivi de 9 zéros » ; 1e-6 signifie « déplacer la virgule de 6 positions vers la gauche ». Les tirets bas dans 1_000_000 sont ignorés par le moteur — ils servent uniquement à aider les humains à lire les grands nombres.

Nombres hexadécimaux, binaires et octaux

JavaScript peut lire des littéraux dans plusieurs systèmes numériques. Ils sont tous stockés sous le même type number — seule la notation diffère :

let hex = 0xFF;    // 255  (base 16, prefix 0x)
let bin = 0b1010;  // 10   (base 2,  prefix 0b)
let oct = 0o744;   // 484  (base 8,  prefix 0o)

La méthode toString

num.toString(base) convertit un nombre en chaîne de caractères dans n'importe quelle base de 2 à 36 — c'est la direction inverse par rapport aux littéraux ci-dessus :

Remarque : pour appeler une méthode directement sur un littéral, vous avez besoin de deux points ou de parenthèses — 255..toString(16) ou (255).toString(16) — car 255. est interprété comme un point décimal.

Méthodes d'arrondi

JavaScript fournit plusieurs fonctions pour arrondir les nombres :

1. Math.floor() : Arrondit un nombre vers le bas à l'entier le plus proche.

2. Math.ceil() : Arrondit un nombre vers le haut à l'entier le plus proche.

3. Math.round() : Arrondit un nombre à l'entier le plus proche, selon les règles mathématiques standard.

4. Math.trunc() : Supprime tous les chiffres fractionnaires, en tronquant essentiellement le nombre.

La différence entre Math.floor et Math.trunc n'apparaît qu'avec les négatifs : Math.floor(-3.5) vaut -4 (arrondi vers -Infinity), tandis que Math.trunc(-3.5) vaut -3 (supprime simplement la partie fractionnaire). Pour plus de méthodes d'arrondi et d'aide mathématique, consultez le chapitre JavaScript Math.

Formater les nombres : toFixed et toPrecision

Lorsque vous avez besoin d'un nombre sous forme de chaîne avec une présentation fixe — montants, pourcentages, rapports — utilisez ces méthodes plutôt que Math.round :

• toFixed(digits) conserve un nombre fixe de chiffres après le point décimal.
• toPrecision(digits) conserve un nombre fixe de chiffres significatifs.

Ces deux méthodes renvoient des chaînes de caractères. Encapsulez le résultat dans Number() si vous avez besoin d'un nombre. toLocaleString() est la solution idéale pour les séparateurs de milliers et les devises dans la locale de l'utilisateur.

Gérer les calculs imprécis

Comme le type number utilise la virgule flottante binaire, certaines fractions décimales ne peuvent pas être stockées exactement — le fameux 0.1 + 0.2 !== 0.3. Ce n'est pas un bug de JavaScript ; tous les langages IEEE-754 ont ce comportement.

La règle d'or : ne jamais comparer des résultats en virgule flottante avec ===. Soit arrondir les deux valeurs au préalable, soit vérifier que leur différence est inférieure à Number.EPSILON (le plus petit écart entre 1 et le nombre représentable suivant).

Entiers sûrs

Un number ne peut stocker des entiers exactement que jusqu'à Number.MAX_SAFE_INTEGER (2^53 − 1). Au-delà, deux entiers différents peuvent se confondre en une même valeur :

Si vous travaillez avec des identifiants, des horodatages en nanosecondes ou de grands compteurs dépassant cette limite, passez à BigInt.

Valeurs numériques spéciales

Comprendre Infinity, -Infinity et NaN en JavaScript :

• Infinity : Représente l'infini, une valeur supérieure à tout autre nombre. Ce résultat apparaît lorsque vous divisez un nombre par zéro ou lorsque vous dépassez la limite supérieure des nombres en virgule flottante.
• -Infinity : Représente l'infini négatif, une valeur inférieure à tout autre nombre. Cela se produit lorsque vous divisez un nombre négatif par zéro ou que vous dépassez la limite inférieure des nombres en virgule flottante.
• NaN : Signifie « Not-a-Number » (Pas-un-nombre). Cette valeur résulte d'une opération mathématique indéfinie ou non représentable, comme diviser zéro par zéro.

Les méthodes isNaN() et isFinite() permettent de vérifier ces valeurs spéciales :

• isNaN() : Vérifie si une valeur est NaN. Notez que le isNaN() global effectue une coercition de type implicite, donc isNaN('hello') renvoie true. Pour une vérification de type stricte, utilisez Number.isNaN(), qui ne renvoie true que si la valeur est réellement NaN.
• isFinite() : Vérifie si une valeur est un nombre fini, retournant false pour Infinity, -Infinity ou NaN.

Exemples :

• isNaN('hello') renvoie true car la chaîne est coercée en NaN.
• isFinite(2 / 0) renvoie false, car 2 / 0 donne Infinity, qui n'est pas fini.

Conversion numérique : Number(), parseInt et parseFloat

Il existe trois façons courantes de transformer une chaîne de caractères en nombre, et choisir la bonne est important.

Number(value) est strict : la totalité de la chaîne doit être un nombre valide (les espaces sont supprimés), sinon vous obtenez NaN. Une chaîne vide devient 0.

parseInt(value, radix) est souple : il lit de gauche à droite et s'arrête au premier caractère qui ne fait pas partie d'un entier. Si le premier caractère ne peut pas être analysé, il renvoie NaN. Passez toujours le radix (base) pour éviter les surprises.

parseFloat(value) fonctionne comme parseInt mais comprend le point décimal, lisant jusqu'à ce qu'il rencontre un caractère ne faisant pas partie d'un nombre en virgule flottante :

Règle d'or : utilisez Number() lorsque la chaîne doit être entièrement numérique (par exemple, pour valider un champ de formulaire), et parseInt/parseFloat lorsque vous devez extraire un nombre d'un texte comme '100px'.

Conclusion

JavaScript stocke tous les nombres courants sous forme de valeurs en virgule flottante 64 bits, ce qui explique les bizarreries d'arrondi, la limite des entiers sûrs, et pourquoi le formatage et la comparaison nécessitent de la prudence. Savoir quand utiliser toFixed, Number.EPSILON, BigInt ou parseInt vous permet d'écrire du code au comportement prévisible. Continuez avec les guides des types associés : Strings, BigInt, l'objet Math et les Types de données.

Pratique