Numéros JavaScript
JavaScript n'a qu'un seul type de nombre. Les nombres peuvent être écrits avec ou sans décimales.
Exemple
let x = 3.14; // A number with decimals
let y = 3; // A number without decimals
Les nombres très grands ou très petits peuvent être écrits avec une notation scientifique (exposant):
Exemple
let x = 123e5; // 12300000
let y = 123e-5; // 0.00123
Les nombres JavaScript sont toujours en virgule flottante 64 bits
Contrairement à de nombreux autres langages de programmation, JavaScript ne définit pas différents types de nombres, comme les nombres entiers, courts, longs, à virgule flottante, etc.
Les nombres JavaScript sont toujours stockés sous forme de nombres à virgule flottante double précision, conformément à la norme internationale IEEE 754.
Ce format stocke les nombres sur 64 bits, où le nombre (la fraction) est stocké sur les bits 0 à 51, l'exposant sur les bits 52 à 62 et le signe sur le bit 63 :
| Valeur (alias Fraction/Mantisse) | Exposant | Signe |
|---|---|---|
| 52 bits (0 - 51) | 11 bits (52 - 62) | 1 bit (63) |
Précision d'entier
Les nombres entiers (nombres sans point ni exposant) sont précis jusqu'à 15 chiffres.
Exemple
let x = 999999999999999; // x will be 999999999999999
let y = 9999999999999999; // y will be 10000000000000000
Le nombre maximum de décimales est de 17.
Précision flottante
L'arithmétique à virgule flottante n'est pas toujours précise à 100 % :
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;
Ajouter des nombres et des chaînes
AVERTISSEMENT !!
JavaScript utilise l'opérateur + pour l'addition et la concaténation.
Les numéros sont ajouté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 ajoutez 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 ajoutez 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 ajoutez 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 consiste à s'attendre à ce que ce résultat soit 30 :
Exemple
let x = 10;
let y = 20;
let z = "The result is: " + x + y;
Une erreur courante consiste à 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.
Le premier 10 + 20 est ajouté car x et y sont tous deux des nombres.
Alors 30 + "30" est concaténé car z est une chaîne.
Chaînes numériques
Les chaînes JavaScript peuvent avoir un contenu numérique :
let x = 100; // x is a number
let y = "100"; // y is a
string
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 également :
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é JavaScript indiquant qu'un nombre n'est pas un nombre légal.
Essayer de faire de l'arithmétique avec une chaîne non numérique entraînera NaN(Pas un nombre):
Exemple
let x = 100 / "Apple";
Cependant, si la chaîne contient une valeur numérique, le résultat sera un nombre :
Exemple
let x = 100 / "10";
Vous pouvez utiliser la fonction JavaScript globale isNaN()
pour savoir si une valeur n'est pas un nombre :
Exemple
let x = 100 / "Apple";
isNaN(x);
Attention aux NaN. Si vous utilisez NaNdans 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;
NaNest un nombre : typeof NaNrenvoie number:
Exemple
typeof NaN;
Infini
Infinity(ou -Infinity) est la valeur renvoyée par JavaScript si vous calculez un nombre en dehors du plus grand nombre possible.
Exemple
let myNumber = 2;
// Execute until 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;
Infinityest un nombre : typeof Infinityrenvoie 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 non significatif (comme 07).
Certaines versions de JavaScript interprètent les nombres comme octaux s'ils sont écrits avec un zéro non significatif.
Par défaut, JavaScript affiche les nombres sous forme de décimales en base 10 .
Mais vous pouvez utiliser la toString()méthode pour générer des nombres de la base 2
à la base 36 .
L'hexadécimal est en base 16 . La décimale est en base 10 . L'octal est en base 8 . Le binaire est en base 2 .
Exemple
let myNumber = 32;
myNumber.toString(10);
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(8);
myNumber.toString(2);
Numéros 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 aussi ê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 Nombre.
Le newmot clé complique le code et ralentit la vitesse d'exécution.
Les objets numériques 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 ne 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);
Comparing two JavaScript objects always returns false.
Complete JavaScript Number Reference
For a complete Number reference, visit our:
Complete JavaScript Number Reference.
The reference contains descriptions and examples of all Number properties and methods.