Nombre (Number) JavaScript

JavaScript ne possède qu'un seul type de nombre, sans spécification distincte d'entier ou de flottant.

Par conséquent, un nombre peut être écrit en JavaScript, avec ou sans point décimal.

var a =　25;　//　Sans point décimal
var b =　80.05;　　//　Avec un point décimal

Dans les deux cas mentionnés ci-dessus, le type de données est un nombre, et cela reste le même que le nombre soit ou non suivi d'un point décimal.

On peut utiliser la notation exponentielle scientifique en JavaScript pour abréger les nombres très grands ou très petits, comme dans les exemples suivants :

let num1　=　957e8;　//　95700000000
let num2　=　957e-8;//　0.00000957

Les nombres JavaScript sont considérés comme précis, au plus15bits numériques. Cela signifie que le nombre sera arrondi au16bits après la virgule :

let num1　=　999999999999999;　//　La valeur reste inchangée　999999999999999
let num2　=　9999999999999999;//　Arrondi vers le haut à　10000000000000000

Représentation interne des nombres

Contrairement aux autres langages, JavaScript ne définit pas de types de nombres différents, tels que des entiers, des shorts, des longs, des nombres à virgule flottante, etc.

Les nombres JavaScript ont64Précision en bits, ce qui est également appelé double précision.

Représentation interne basée sur IEEE 754Standard.

64Les bits sont répartis entre le signe, l'exponentiel et le nombre décimal, comme suit :

Addition des nombres et concaténation des chaînes

Comme mentionné précédemment dans le chapitre,+Les opérateurs sont utilisés pour l'addition des nombres et la concaténation des chaînes.

Si c'est un nombre, additionnez les nombres. Si c'est une chaîne, concaténez les chaînes.

Si vous ajoutez deux nombres, le résultat sera un nombre :

let x =　50;
let y =　10;
let z = x　+　y;　　//　z =　60 (un nombre)

Si deux chaînes, le résultat sera une concaténation de chaînes :

let x = "50";
let y = "10";
let z = x　+　y;　　//　z =　5010　(une chaîne)

Si un nombre et une chaîne, le résultat sera une concaténation de chaînes :

let x =　50;
let y = "10";
let z = x　+　y;　　//　z =　5010　(une chaîne)

Si une chaîne et un nombre, le résultat sera une concaténation de chaînes :

let x = "50";
let y =　10;
let z = x　+　y;　　//　z =　5010　(une chaîne)

JavaScript calcule l'expression de gauche à droite.

Dans l'exemple suivant, tout d'abord50 + 10Somme, car x et y sont des nombres, puis60 +"30” est connecté, car z est une chaîne :

let x =　50;
let y =　10;
let z = "30";
let sum = x　+　y　+　z;　　//　sum =　6030 (une chaîne)

Une erreur courante, on s'attend à ce résultat :60 :

let x =　50;
let y =　10;
let z = "The sum is: "　+　x　+　y;

Vous pouvez utiliser des parenthèses pour résoudre ce problème :

let x =　50;
let y =　10;
let z = "The sum is: "　+　(x　+　y);

Chaînes numériques et expressions mathématiques

Les chaînes JavaScript peuvent contenir des valeurs numériques.

　　let x =　50;　　//　x est un nombre
　　let y = "50";　　//　y est une chaîne

Si une chaîne contient une valeur numérique, vous pouvez effectuer des expressions mathématiques en JavaScript.

Division possible :

let x = "50"　/　"10";　　//　x　　=　5

Multiplication possible :

let x = "50"　*　"10";　　//　x　　=　500

Opérations exponentielles possibles :

let x = "5"　**　"3";　　//　x　　=　125

Incrémentation possible :

let x = "50";
x++;　//　x　　=　51

Soustraction possible :

let x = "50"　-　"10";　　//　x　　=　40

Ajout impossible :

let x = "50"　+　"10";　　//　x　　=　5010

Attention :Si vous ajoutez deux chaînes de caractères, le résultat sera une concaténation de chaînes.

JavaScript NaN-Nombre illégal

Dans JavaScript, NaN est un mot réservé pour indiquer que le nombre n'est pas un nombre légal.

Si vous essayez d'effectuer une opération mathématique sur une valeur numérique et une valeur non numérique, NaN sera retourné.

var x　=　50　/　"oldtoolbag.com";　　//　x　　=　NaN (Not a Number)

Mais si la chaîne contient une valeur numérique, vous pouvez utiliser JavaScript pour exécuter des expressions mathématiques :

var x　=　50　/　"10";　　//　x　　=　5

Vous pouvez utiliser le JavaScript global isNaN()une fonction pour déterminer si une valeur est un nombre :

var x　=　50　/　"oldtoolbag.com";
isNaN(x);//　retournera true car x n'est pas un nombre

Lorsque vous assignez une valeur à une variable NaN dans une opération NaN, même si l'autre opérande est un nombre légitime, cela entraînera une valeur :

var x　=　NaN;
var y　=　27;
var z　=　x　+　y;　　//　z　　=　NaN

NaN est un nombre ; typeof NaN retourne number :

typeof NaN;　　　//　will return "number"

Infini JavaScript

Infinity (infini positif) ou-Infinity (infini négatif) si le nombre dépasse le plus grand nombre disponible en JavaScript, il sera retourné.

Ces cas se produiront également pour des valeurs non définies, par exemple lors de la division par zéro :

var x　=　5　/　0;　　　//　retournera l'infini
var y　=　-5　/　0;　　//　retournera l'infini négatif

En termes techniques, Infinity (infini positif) s'affichera lorsque le nombre dépasse le nombre1.797693134862315E+308，ce qui représente la limite supérieure en JavaScript.

De même,-Infinity (infini négatif) s'affichera lorsque le nombre dépasse la limite inférieure-1.797693134862316E+308.

Infinity est un nombre : typeof Infinity retourne number :

typeof Infinity;　　　//　will return "number"

Le nombre Infinity peut également être utilisé dans la boucle :

var num =　5;
while (num != Infinity) {　
//　Le code ici s'exécutera jusqu'à ce que num = ∞
}

JavaScript Radix

Par défaut, JavaScript affiche les nombres en utilisant10estde basedécimal.

un nombre peut également être représenté en hexadécimal (base16），binaire (base2）et octal (base8）représenté.

Le préfixe d'un nombre hexadécimal est 0x :

var x = 0xFF;　　//　x　　=　255

Le préfixe d'un nombre binaire est 0b :

var x = 0b1111;//　x　　=　15

Ne pas écrire un nombre commençant par zéro (par exemple 0121）。Si vous écrivez un nombre avec un zéro en tête, JavaScript interprétera le nombre comme octal :

var x = 016;

Vous pouvez utiliser cettetoString()la méthode à2à36le retour d'un nombre en nombre.

en hexadécimalBase16en décimalBase10en octalBase8en binarisBase2.

var num =　255;
num.toString(10);　　//　returns　255
num.toString(16);　　//　returns ff
num.toString(8);　　　//　returns　377
num.toString(2);　　　//　returns　11111111

Primitif numérique et objet numérique

En règle générale, les nombres JavaScript sont créés à partir de valeurs littérales :

var num =　50;

Mais, vous pouvez également utiliser le mot-clé new pour définir un nombre en tant qu'objet :

var num = new Number(50);

Pour tester la différence entre les deux, nous allons initialiser un primitif numérique et un objet numérique.

var num1　=　50;
var num2　= new Number(50);
typeof num1//　returns number
typeof num2//　returns object

Attention :Ne créez pas de nombres en tant qu'objets. Cela ralentira l'exécution et produira certains résultats inattendus.

Lorsque vous utilisez l'opérateur ==, un nombre est égal :

var num1　=　50;
var num2　= new Number(50);
document.write(num1　== num2);　//　retourne true, car num1et num2Ils ont des valeurs égales

Lorsque vous utilisez l'opérateur ===, des nombres égaux ne sont pas égaux, car l'opérateur === attend que la valeur et le type soient égaux :

var num1　=　50;
var num2　= new Number(50);
document.write(num1　=== num2);　//　retourne false, car num1et num2Ils ont des types différents

Impossible de comparer les objets :

var num1　= new Number(50);
var num2　= new Number(50);
document.write(num1　== num2);　//　retourne false, car num1et num2C'est des objets différents
document.write(num1　=== num2);　//　retourne false, car num1et num2C'est des objets différents

Attention à la différence entre (==) et (===). Comparer deux objets JavaScript retournera toujours false.