Les types de données

Une valeur en JavaScript est toujours d’un certain type. Par exemple, une chaîne de caractères ou un nombre.

Il existe huit types de données de base en JavaScript. Ici, nous les couvrirons en général et dans les prochains chapitres, nous parlerons de chacun d’eux en détail.

Nous pouvons mettre n’importe quel type dans une variable. Par exemple, une variable peut à un moment être une chaîne de caractères puis stocker un nombre :

          // pas d'erreur
let message = "hello";
message = 123456;
        

Les langages de programmation qui permettent de telles choses sont appelés “typés dynamiquement”, ce qui signifie qu’il existe des types de données, mais que les variables ne sont liées à aucun d’entre eux.

Number

          let n = 123;
n = 12.345;
        

Le type number sert à la fois à des nombres entiers et à des nombres à virgule flottante.

Il existe de nombreuses opérations pour les nombres, par ex. multiplication *, division /, addition +, soustraction - et ainsi de suite.

Outre les nombres réguliers, il existe des “valeurs numériques spéciales” qui appartiennent également à ce type: Infinity, -Infinity et NaN.

Infinity représente l’Infini ∞ mathématique. C’est une valeur spéciale qui est plus grande que n’importe quel nombre.

Nous pouvons l’obtenir à la suite d’une division par zéro :
```
alert( 1 / 0 ); // Infinity
```
Ou mentionnez-le simplement dans le code directement :
```
alert( Infinity ); // Infinity
```
NaN représente une erreur de calcul. C’est le résultat d’une opération mathématique incorrecte ou non définie, par exemple :
```
alert( "pas un nombre" / 2 ); // NaN, une telle division est erronée
```
NaN est contagieux. Toute autre opération sur NaN donnerait un NaN :
```
alert( NaN + 1 ); // NaN
alert( 3 * NaN ); // NaN
alert( "not a number" / 2 - 1 ); // NaN
```
Donc, s’il y a NaN quelque part dans une expression mathématique, il se propage à l’ensemble du résultat (il n’y a qu’une seule exception : NaN ** 0 vaut 1).

Faire des maths est sans danger en JavaScript. Nous pouvons faire n’importe quoi : diviser par zéro, traiter les chaînes non numériques comme des nombres, etc.

Le script ne s’arrêtera jamais avec une erreur fatale (“die”). Au pire, nous aurons NaN comme résultat.

Les valeurs numériques spéciales appartiennent formellement au type “number”. Bien sûr, ce ne sont pas des nombres au sens commun de ce mot.

Nous allons en voir plus sur le travail avec les nombres dans le chapitre Nombres.

BigInt

En JavaScript, le type “number” ne peut pas représenter des valeurs entières supérieures à (2⁵³-1) (c’est 9007199254740991), ou moins que -(2⁵³-1) pour les chiffres négatifs. C’est une limitation technique causée par leur représentation interne.

Pour être vraiment précis, le type “number” peut stocker des entiers plus grands (jusqu’à 1.7976931348623157 * 10³⁰⁸), mais en dehors de la plage d’entiers sûrs ±(2 ⁵³-1) il y aura une erreur de précision, car tous les chiffres ne rentrent pas dans le stockage 64 bits fixe. Ainsi, une valeur “approximative” peut être stockée.

Par exemple, ces deux nombres (juste au-dessus de la plage de sécurité) sont identiques :

          console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992
        

Ainsi, tous les entiers impairs supérieurs à (2⁵³-1) ne peuvent pas du tout être stockés dans le type “number”.

Dans la plupart des cas, la plage ±(2⁵³-1) est tout à fait suffisante, mais parfois nous avons besoin de toute la plage de très grands nombres entiers, par ex. pour la cryptographie ou les horodatages de précision à la microseconde.

BigInt a récemment été ajouté au langage pour représenter des entiers de longueur arbitraire.

Une valeur BigInt est créé en ajoutant n à la fin d’un entier :

          // le "n" à la fin signifie que c'est un BigInt
const bigInt = 1234567890123456789012345678901234567890n;
        

Comme les chiffres BigInt sont rarement nécessaires, nous leur avons consacré un chapitre dédié BigInt. Lisez-le lorsque vous avez besoin d’aussi gros chiffres.

À l’heure actuelle, BigInt est pris en charge dans Firefox/Chrome/Edge/Safari, mais pas dans IE.

You can check MDN BigInt compatibility table to know which versions of a browser are supported.

String

Une chaîne de caractères en JavaScript doit être entre guillemets.

          let str = "Hello";
let str2 = 'Single quotes are ok too';
let phrase = `can embed another ${str}`;
        

En JavaScript, il existe 3 types de guillemets.

Double quotes: "Hello".
Single quotes: 'Hello'.
Backticks: `Hello`.

Les guillemets simples et doubles sont des guillemets “simples”. Il n’y a pratiquement pas de différence entre eux en JavaScript.

Les backticks sont des guillemets “à fonctionnalité étendue”. Ils nous permettent d’intégrer des variables et des expressions dans une chaîne en les encapsulant dans ${…}, par exemple :

let name = "John";

// une variable encapsulée
alert( `Hello, ${name}!` ); // Hello, John!

// une expression encapsulée
alert( `the result is ${1 + 2}` ); // le résultat est 3

L’expression à l’intérieur de ${…} est évaluée et le résultat devient une partie de la chaîne. On peut y mettre n’importe quoi : une variable comme name ou une expression arithmétique comme 1 + 2 ou quelque chose de plus complexe.

Veuillez noter que cela ne peut être fait que dans les backticks. Les autres guillemets ne permettent pas une telle intégration !

alert( "the result is ${1 + 2}" ); // le résultat est ${1 + 2} (les doubles quotes ne font rien)

Nous couvrirons les chaînes de caractères plus en détails dans le chapitre Strings.

Dans certains langages, il existe un type spécial “character” pour un seul caractère. Par exemple, en langage C et en Java, il s’agit de “char”.

En JavaScript, ce type n’existe pas. Il n’y a qu’un seul type: string. Une chaîne de caractères peut être composée de zéro caractère (être vide), d’un caractère ou de plusieurs d’entre eux.

Boolean (type logique)

Le type booléen n’a que deux valeurs: true et false.

Ce type est couramment utilisé pour stocker des valeurs oui / non: true signifie “oui, correct” et false signifie “non, incorrect”.

Par exemple :

          let nameFieldChecked = true; // oui, le champ de nom est coché
let ageFieldChecked = false; // non, le champ d'âge n'est pas coché
        

Les valeurs booléennes résultent également de comparaisons :

let isGreater = 4 > 1;

alert( isGreater ); // true (le résultat de la comparaison est "oui")

Nous couvrirons plus profondément les booléens plus tard dans le chapitre Opérateurs logiques.

La valeur “null”

La valeur spéciale null n’appartient à aucun type de ceux décrits ci-dessus.

Il forme un type bien distinct qui ne contient que la valeur null :

let age = null;

En JavaScript, null n’est pas une “référence à un objet non existant” ou un “pointeur nul” comme dans d’autres langages.

C’est juste une valeur spéciale qui a le sens de “rien”, “vide” ou “valeur inconnue”.

Le code ci-dessus indique que l’age est inconnu.

La valeur “undefined”

La valeur spéciale undefined se distingue des autres. C’est un type à part entière, comme null.

La signification de undefined est “la valeur n’est pas attribuée”.

Si une variable est déclarée mais non affectée, alors sa valeur est exactement undefined :

let age;

alert(age); // affiche "undefined"

Techniquement, il est possible d’affecter explicitement undefined à une variable :

let age = 100;

// change the value to undefined
age = undefined;

alert(age); // "undefined"

… Mais il n’est pas recommandé de faire cela. Normalement, nous utilisons null pour assigner une valeur “vide” ou “inconnue” à une variable, tandis que undefined est réservé comme valeur initiale par défaut pour les éléments non attribués.

Objects et Symbols

Le type object est spécial.