Variables, types et opérateurs

JavaScript est le langage de programmation du Web : il s’exécute dans tous les navigateurs pour rendre les pages interactives, et côté serveur avec Node.js. Dans ce cours, nos exercices s’exécutent avec Node, sans page web : on se concentre sur le langage lui-même.

Déclarer des variables

const prixUnitaire = 19.9;   // const : ne peut pas être réaffectée
let quantite = 2;            // let : peut changer
quantite = 3;                // OK
// prixUnitaire = 25;        // TypeError : affectation à une constante

console.log(prixUnitaire * quantite); // affiche 59.7 (environ, voir plus bas)

Règle simple : utilisez const par défaut, et let seulement si vous devez réaffecter la variable. L’ancien mot-clé var a des comportements piégeux (portée de fonction, « remontée » de la déclaration) : on ne l’utilise plus dans du code moderne.

Les noms suivent la convention camelCase (prixTotal, estConnecte) et doivent être parlants.

Les types primitifs

const nom = "Léa";             // string (chaîne)
const age = 31;                // number (entiers et décimaux)
const estAbonne = true;        // boolean
let commentaire;               // undefined : déclarée sans valeur
const coupon = null;           // null : absence volontaire de valeur
const grandNombre = 9007199254740993n; // bigint : entiers arbitrairement grands

console.log(typeof nom);       // "string"
console.log(typeof age);       // "number"
console.log(typeof null);      // "object" : bizarrerie historique à connaître

Il existe aussi le type symbol, plus rare. Tout le reste (tableaux, objets, fonctions) est de type objet.

Opérateurs et chaînes

const total = 10 + 5 * 2;      // 20 : la multiplication est prioritaire
const reste = 17 % 5;          // 2 : reste de la division (modulo)
const carre = 3 ** 2;          // 9 : puissance
let compteur = 0;
compteur += 1;                 // compteur = compteur + 1
compteur++;                    // incrémente de 1

// Gabarits de chaînes (backticks) : on insère des expressions avec ${...}
const message = `Bonjour ${nom}, vous avez ${age} ans.`;
const ligne = `Total : ${(19.9 * 3).toFixed(2)} €`;  // "Total : 59.70 €"

Les chaînes ont de nombreuses méthodes : nom.length, nom.toUpperCase(), texte.trim(), texte.includes("@"), texte.split(","), texte.padStart(2, "0").

Comparer : toujours avec ===

5 === 5        // true
5 === "5"      // false : types différents
5 == "5"       // true : == convertit les types avant de comparer (piège)
0 == false     // true (!)
null == undefined // true

=== et !== comparent sans conversion : utilisez-les systématiquement. Autres opérateurs : <, >, <=, >=, et les opérateurs logiques && (et), || (ou), ! (non).

Convertir explicitement

Les données venant d’un formulaire ou d’une URL sont des chaînes. Il faut les convertir :

const saisie = "42";
const n = Number(saisie);           // 42
"3" + 4                             // "34" : + concatène si une chaîne est présente
Number("3") + 4                     // 7
Number("douze")                     // NaN (Not a Number)
Number.isNaN(Number("douze"))       // true
Number.parseFloat("12.5 kg")        // 12.5 : lit le début de la chaîne
String(42)                          // "42"

Le piège des décimaux

0.1 + 0.2              // 0.30000000000000004

Les nombres sont stockés en virgule flottante binaire : certains décimaux ne sont pas représentables exactement. Pour l’argent, calculez en centimes entiers (1990 plutôt que 19.90) et formatez seulement à l’affichage.