Adloun

Valeurs, types et opérateurs

Cours · JavaScript : rendre le Web interactif (école d'ingénieur), chapitre 2 · école d'ingénieur, informatique · le début du chapitre, la suite sur Adloun

Pour afficher le total d'un panier, la Librairie du Campus doit additionner des prix, multiplier par des quantités, comparer le résultat au seuil de la livraison offerte, puis écrire « 86,00 € ». Rien de plus simple en apparence. Pourtant, en JavaScript, 0.1 + 0.2 ne vaut pas 0.3, "5" + 2 vaut "52", et une quantité nulle peut devenir 1 par mégarde. Ces surprises ont toutes une explication simple, à condition de savoir quelles valeurs manipule le langage et comment il les convertit.

Ce chapitre présente les briques du langage : variables, types de valeurs, nombres, chaînes de caractères, booléens, les deux « absences de valeur » null et undefined, et les opérateurs. Le programmeur Java y retrouvera beaucoup de choses connues ; les encadrés signalent les différences.

Objectifs du chapitre

  • Déclarer des variables avec const et let, et choisir entre les deux.
  • Connaître les types de valeurs et les identifier avec typeof.
  • Calculer avec le type number en connaissant ses limites : flottants, NaN, entiers sûrs ; manipuler des prix en centimes.
  • Manipuler des chaînes, écrire des gabarits.
  • Prévoir les conversions implicites ; employer ===, ?? et ?..

2.1 Variables : const et let

Une variable est un nom associé à une valeur. On la déclare avec l'un des deux mots const et let, sans indiquer de type.


const titre = "CSS — Mettre en forme le Web";
let quantite = 1;
console.log(titre, quantite);
quantite = quantite + 2;
console.log(titre, quantite);
let remise;
console.log(remise);
remise = 0.05;
console.log(remise);
remise = remise * 2;
console.log(remise);

CSS — Mettre en forme le Web 1
CSS — Mettre en forme le Web 3
undefined
0.05
0.1
Définition 2.1const et let

const nom = valeur; déclare une variable constante : elle reçoit une valeur à sa déclaration, et ne peut plus être réaffectée. let nom = valeur; déclare une variable modifiable ; sans valeur initiale (let remise;), elle vaut undefined. Dans les deux cas, déclarer deux fois le même nom dans le même bloc est une erreur de syntaxe.

Réaffecter une constante échoue à l'exécution :


const prix = 27;
prix = 25;
console.log(prix);

const.mjs:2
prix = 25;
     ^

TypeError: Assignment to constant variable.

Méthode — const par défaut

Déclarer chaque variable avec const, et ne passer à let que si l'on doit la réaffecter (un compteur, un total que l'on accumule). Le lecteur sait alors qu'une variable const garde la même valeur du début à la fin ; ESLint signale d'ailleurs un let jamais réaffecté (règle prefer-const).

Et var ?

Le code ancien déclare ses variables avec var. Ce mot a des règles de portée surprenantes, expliquées au chapitre 4 : on ne l'emploie plus. Une variable const ressemble à une variable final de Java, avec une nuance que le chapitre 5 précisera : si la valeur est un objet, l'objet lui-même reste modifiable.

2.2 Les types de valeurs

En Java, une variable a un type, fixé à sa déclaration. En JavaScript, seules les valeurs ont un type ; une même variable peut contenir successivement un nombre, une chaîne, un booléen.


let valeur = 42;
console.log(valeur, typeof valeur);
valeur = "quarante-deux";
console.log(valeur, typeof valeur);
valeur = valeur.length > 10;
console.log(valeur, typeof valeur);

42 number
quarante-deux string
true boolean
Définition 2.2Les huit types

Une valeur JavaScript est soit d'un des sept types primitifs, soit un objet :

  • number les nombres, entiers ou non (42, 3.14) ;
  • bigint les entiers de taille arbitraire (10n) ;
  • string les chaînes de caractères ;
  • boolean true et false ;
  • undefined la valeur undefined seule : « pas encore de valeur » ;
  • null la valeur null seule : « délibérément aucune valeur » ;
  • symbol des identifiants uniques, d'usage avancé ;
  • object tout le reste : objets, tableaux, fonctions, dates…

Une valeur primitive est immuable : aucune opération ne la modifie, elles en produisent de nouvelles.

L'opérateur typeof donne, sous forme de chaîne, le type d'une valeur :


console.log(typeof 42);
console.log(typeof 3.14);
console.log(typeof "Java");
console.log(typeof true);
console.log(typeof undefined);
console.log(typeof null);
console.log(typeof 10n);
console.log(typeof Symbol("isbn"));
console.log(typeof { titre: "CSS" });
console.log(typeof ["HTML", "CSS"]);
console.log(typeof function () {});

number
number
string
boolean
undefined
object
bigint
symbol
object
object
function

Deux réponses trompeuses de typeof

typeof null vaut "object" : c'est une erreur de la toute première version du langage, conservée pour ne pas casser les pages existantes. Pour tester l'absence de valeur, on compare : valeur === null. Et un tableau est un objet comme un autre pour typeof ; on le reconnaît avec Array.isArray(valeur). À l'inverse, une fonction, qui est aussi un objet, a droit à sa réponse propre, "function".

2.3 Les nombres

Proposition 2.3Un seul type de nombres

Tous les nombres de JavaScript, entiers ou non, sont du type number : des flottants en double précision (64 bits, norme IEEE 754), comme les double de Java. Il n'y a ni int, ni long, ni division entière.


const pasUnNombre = 0 / 0;
console.log(7 / 2, 7 % 2, -7 % 2);
console.log(2 ** 10, 1e3, 2.5e-3);
console.log(1 / 0, -1 / 0, pasUnNombre);
console.log(typeof pasUnNombre, pasUnNombre === pasUnNombre);
console.log(Number.isNaN(pasUnNombre));
console.log(Math.round(2.5), Math.round(-2.5), Math.trunc(-2.7), Math.floor(-2.7));
console.log(Math.max(12, 45, 7), Math.min(), Math.sqrt(2));
console.log(Number.MAX_SAFE_INTEGER, 2 ** 53 + 1);

3.5 1 -1
1024 1000 0.0025
Infinity -Infinity NaN
number false
true
3 -2 -2 -3
45 Infinity 1.4142135623730951
9007199254740991 9007199254740992

Ligne par ligne :

La suite du cours est sur Adloun

Le chapitre en entier, formules et figures comprises, avec le tuteur, les fiches, les QCM et les exercices.

Lire la suite du cours

En accès libre, sans inscription.

Exercices corrigés de ce chapitre

Lire la suite du cours →