Nombres JavaScript
Types de Nombres
JavaScript ne possède qu'un seul type de nombre.
Les nombres peuvent être écrits avec ou sans décimales.
Exemple
let x = 3.14; // Un nombre avec des décimales
let y = 3; // Un nombre sans décimales
Les nombres très grands ou très petits peuvent être écrits en notation scientifique (exposant) :
Exemple
let x = 123e5; // 12300000
let y = 123e-5; // 0.00123
Les Nombres JavaScript sont Toujours des Flottants à 64 bits
Contrairement à de nombreux autres langages de programmation, JavaScript ne définit pas différents types de nombres, comme les entiers, short, long, flottants, etc.
Les nombres JavaScript sont toujours stockés en tant que nombres flottants à double précision, suivant la norme internationale IEEE 754.
Ce format stocke les nombres en 64 bits, où le nombre (la fraction) est stocké dans les bits 0 à 51, l'exposant dans les bits 52 à 62, et le signe dans le bit 63 :
| Valeur (ou Fraction/Mantisse) | Exposant | Signe |
|---|---|---|
| 52 bits (0 - 51) | 11 bits (52 - 62) | 1 bit (63) |
Remarque
La plupart des langages de programmation ont de nombreux types de nombres :
Nombres entiers :
byte (8 bits), short (16 bits), int (32 bits), long (64 bits)
Nombres réels (flottants) :
float (32 bits), double (64 bits).
Les nombres JavaScript sont toujours des doubles (flottants à 64 bits).
Précision des Entiers
Les entiers (nombres sans virgule ni notation exponentielle) sont précis jusqu'à 15 chiffres.
Exemple
let x = 999999999999999; // x sera 999999999999999
let y = 9999999999999999; // y sera 10000000000000000 Le nombre maximum de décimales est 17.
Précision Flottante
L'arithmétique flottante n'est pas toujours 100 % précise :
let x = 0.2 + 0.1;
Pour résoudre le problème ci-dessus, il est utile de multiplier et de diviser :
let x = (0.2 * 10 + 0.1 * 10) / 10; Addition de Nombres et de Chaînes
AVERTISSEMENT !!
JavaScript utilise l'opérateur + pour l'addition et la concaténation.
Les nombres sont additionnés. Les chaînes sont concaténées.
Si vous additionnez deux nombres, le résultat sera un nombre :
Exemple
let x = 10;
let y = 20;
let z = x + y; Si vous additionnez deux chaînes, le résultat sera une concaténation de chaînes :
Exemple
let x = "10";
let y = "20";
let z = x + y; Si vous additionnez un nombre et une chaîne, le résultat sera une concaténation de chaînes :
Exemple
let x = 10;
let y = "20";
let z = x + y; Si vous additionnez une chaîne et un nombre, le résultat sera une concaténation de chaînes :
Exemple
let x = "10";
let y = 20;
let z = x + y; Une erreur courante est de s'attendre à ce que ce résultat soit 30 :
Exemple
let x = 10;
let y = 20;
let z = "Le résultat est : " + x + y; Une erreur courante est de s'attendre à ce que ce résultat soit 102030 :
Exemple
let x = 10;
let y = 20;
let z = "30";
let result = x + y + z; L'interpréteur JavaScript fonctionne de gauche à droite.
D'abord, 10 + 20 est additionné car x et y sont tous deux des nombres.
Ensuite, 30 + "30" est concaténé car z est une chaîne.
Chaînes Numériques
Les chaînes JavaScript peuvent contenir des valeurs numériques :
let x = 100; // x est un nombre
let y = "100"; // y est une chaîne JavaScript essaiera de convertir les chaînes en nombres dans toutes les opérations numériques :
Cela fonctionnera :
let x = "100";
let y = "10";
let z = x / y;
Cela fonctionnera aussi :
let x = "100";
let y = "10";
let z = x * y;
Et cela fonctionnera :
let x = "100";
let y = "10";
let z = x - y;
Mais cela ne fonctionnera pas :
let x = "100";
let y = "10";
let z = x + y;
Dans le dernier exemple, JavaScript utilise l'opérateur + pour concaténer les chaînes.
NaN - Pas un Nombre
NaN est un mot réservé de JavaScript indiquant qu'un nombre n'est pas un nombre valide.
Essayer de faire des calculs avec une chaîne non numérique donnera NaN (Pas un Nombre) :
Exemple
let x = 100 / "Pomme";
Cependant, si la chaîne est numérique, le résultat sera un nombre :
Exemple
let x = 100 / "10"; Vous pouvez utiliser la fonction JavaScript globale isNaN() pour déterminer si une valeur n'est pas un nombre :
Exemple
let x = 100 / "Pomme";
isNaN(x); Faites attention à NaN . Si vous utilisez NaN dans une opération mathématique, le résultat sera également NaN :
Exemple
let x = NaN;
let y = 5;
let z = x + y; Ou le résultat pourrait être une concaténation comme NaN5 :
Exemple
let x = NaN;
let y = "5";
let z = x + y; NaN est un nombre : typeof NaN retourne number :
Exemple
typeof NaN; Infini
Infinity (ou -Infinity ) est la valeur que JavaScript renverra si vous calculez un nombre en dehors de la plage des plus grands nombres possibles.
Exemple
let myNumber = 2;
// Exécute jusqu'à Infinity
while (myNumber != Infinity) {
myNumber = myNumber * myNumber;
} La division par 0 (zéro) génère également Infinity :
Exemple
let x = 2 / 0;
let y = -2 / 0; Infinity est un nombre : typeof Infinity retourne number .
Exemple
typeof Infinity; Hexadécimal
JavaScript interprète les constantes numériques comme hexadécimales si elles sont précédées de 0x.
Exemple
let x = 0xFF; N'écrivez jamais un nombre avec un zéro initial (comme 07).
Certaines versions de JavaScript interprètent les nombres comme octaux s'ils sont écrits avec un zéro initial.
Par défaut, JavaScript affiche les nombres comme des décimales en base 10 .
Mais vous pouvez utiliser la méthode toString() pour afficher des nombres de base 2 à base 36 .
L'hexadécimal est en base 16 . Le décimal est en base 10 . L'octal est en base 8 . Le binaire est en base 2 .
Exemple
let myNumber = 32;
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(12);
myNumber.toString(10);
myNumber.toString(8);
myNumber.toString(2);
Les Nombres JavaScript en tant qu'Objets
Normalement, les nombres JavaScript sont des valeurs primitives créées à partir de littéraux :
let x = 123;
Mais les nombres peuvent également être définis comme des objets avec le mot-clé new :
let y = new Number(123);
Exemple
let x = 123;
let y = new Number(123);
Ne créez pas d'objets Number.
Le mot-clé new complique le code et ralentit la vitesse d'exécution.
Les objets Number peuvent produire des résultats inattendus :
Lors de l'utilisation de l'opérateur == , x et y sont égaux :
let x = 500;
let y = new Number(500); Lors de l'utilisation de l'opérateur === , x et y sont pas égaux .
let x = 500;
let y = new Number(500); Notez la différence entre (x==y) et (x===y) .
(x == y) vrai ou faux ?
let x = new Number(500);
let y = new Number(500); (x === y) vrai ou faux ?
let x = new Number(500);
let y = new Number(500); Comparer deux objets JavaScript renvoie toujours faux .