À propos de Les nombres
Il existe deux types de nombres différents en JavaScript : les nombres et les « bigints ».
Les nombres sont les plus utilisés et représentent le type de données numérique au format à virgule flottante double précision 64 bits.
-
number : un type de données numérique au format à virgule flottante double précision 64 bits (IEEE 754).
Par exemple -6, -2.4, 0, 0.1, 1, 3.14, 16.984025, 25, 976, 1024.0 et 500000.
-
bigint : un type de données numérique qui peut représenter des entiers au format de précision arbitraire.
Par exemple -12n, 0n, 4n et 9007199254740991n.
let numericValue = 42;
// => 42
Un littéral numérique comme 42 dans du code JavaScript est une valeur à virgule flottante, pas un entier.
Il n'existe pas de type entier distinct couramment utilisé.
Le type bigint n'est pas conçu pour remplacer le type number dans les usages quotidiens.
42 reste un Number, et non un BigInt.
Les nombres peuvent aussi s'écrire sous forme de littéraux comme 0b101, 0o13, 0x0A. Pour en savoir plus sur la grammaire lexicale des nombres, voir ici.
Notations particulières
Notation exponentielle
La notation E indique un nombre qui doit être multiplié par 10 élevé à une puissance donnée.
Le format de la notation E consiste à écrire un nombre, suivi de e ou E, puis de la puissance de 10 par laquelle multiplier.
const num = 3.125e7;
// => 31250000
// The notation essentially says, "Take 3.125 and multiply it by 10^7".
La notation E peut aussi servir à représenter de très petits nombres :
const num = 325987e-6; // Equals 0.325987
// The notation essentially says, "Take 325987 and multiply it by 10^-6.
Notation avec des tirets bas
On peut utiliser des tirets bas pour rendre les grands nombres plus faciles à lire.
Le compilateur ignore complètement les tirets bas.
const num = 1_000_000; // You can read this as 1,000,000
console.log(num);
// => 1000000
Objets intégrés
Deux objets intégrés sont utiles pour manipuler des nombres :
Math inclut aussi des méthodes pour arrondir les nombres.
Tu peux en savoir plus sur les options d'arrondi disponibles dans cet article de javascript.info sur l'arrondi.
Math.floor(234.34); // => 234
Math.ceil(234.34); // => 235
L'object global intégré Number est aussi une function globale qui peut servir à convertir en number presque n'importe quoi qui ressemble à un nombre.
Il est moins permissif que le parsing d'une string en number.
const date = new Date('December 17, 1995 03:24:00');
const unix = Number(date);
unix;
// => 819199440000
Il existe trois types de valeurs maximales (et minimales / les plus négatives) pour les nombres en JavaScript :
-
VALUE : données par Number.MAX_VALUE et Number.MIN_VALUE
-
INFINITY : données par Number.POSITIVE_INFINITY et Number.NEGATIVE_INFINITY
-
SAFE_INTEGER : données par Number.MAX_SAFE_INTEGER et Number.MIN_SAFE_INTEGER
En raison de la façon dont les nombres sont implémentés en JavaScript, il n'est pas possible de représenter tous les nombres entre Number.MIN_VALUE et Number.MAX_VALUE.
En revanche, tous les nombres entre Number.MIN_SAFE_INTEGER - 1 et Number.MAX_SAFE_INTEGER + 1 peuvent être représentés.
Valeurs numériques particulières
JavaScript possède plusieurs valeurs numériques particulières :
- Deux valeurs d'erreur,
NaN et Infinity.
- Deux valeurs pour zéro,
+0 et -0.
NaN : Not a Number
La valeur d'erreur NaN (aussi appelée « Not a Number ») est produite dans les cas suivants.
NaN est la seule valeur qui n'est pas égale à elle-même :
NaN === NaN; // => false
Pour vérifier si une valeur est NaN, tu dois utiliser la fonction globale isNaN() :
isNaN(NaN); // => true
isNaN(123); // => false
Infinity
Infinity est une valeur d'erreur qui indique l'un de deux problèmes :
Infinity est plus grand que tout autre nombre (sauf NaN).
De même, -Infinity est plus petit que tout autre nombre (sauf NaN).
La fonction globale isFinite() permet de vérifier si une valeur est un vrai nombre (ni infini, ni string) :
isFinite(80085); // => true
isFinite(Infinity); // => false
isFinite(NaN); // => false
Les deux zéros
+0 et -0 sont des nombres distincts en JavaScript. Ils peuvent apparaître lorsqu'on représente un nombre si petit qu'il est impossible de le distinguer de 0.
Le zéro signé permet de noter « de quelle direction » on s'est approché de zéro, c'est-à-dire le signe que le nombre avait avant d'être considéré comme nul.
La bonne pratique est de faire comme s'il n'existait qu'un seul zéro.
Comparaison
Deux nombres sont considérés comme égaux s'ils ont la même valeur.
1 == 1.0;
// => true
1 === 1.0;
// => true
// Remember, all numbers are floating-points, so this is
// different syntax for the exact same value.
1 === 1n;
// => false
// Strictly checking a number against a bigint will always result
// in false.
Voir la comparaison pour plus d'informations sur les comparaisons en général et sur la comparaison de valeurs numériques en JavaScript.
Pièges
Comme les nombres en JavaScript sont des nombres à virgule flottante, tous les calculs utilisant ces valeurs sont des calculs en virgule flottante.
Par conséquent, en JavaScript :
0.1 + 0.2 === 0.3;
// => false
Voir 0.30000000000000004.com pour une brève explication, et l'annexe D du guide Numerical Computation Guide d'Oracle, « What Every Computer Scientist Should Know About Floating-Point Arithmetic », pour une explication approfondie.
20 exercices
Apprends Les nombres
