Variables et types primitifs

Objectifs

À la fin de cette leçon, vous saurez :

• déclarer une variable avec let et const ;
• nommer correctement une variable ;
• différencier les types primitifs de JavaScript ;
• utiliser les opérateurs utiles.

🔗 Pour vous rafraîchir la mémoire : votre premier programme Node

Variables : conteneurs d'informations

let age = 20;
const name = "Paul";

• let déclare une variable modifiable.
• const déclare une valeur constante : impossible de la réaffecter.

L'erreur la plus fréquente :

const name = "Paul";
name = "Jean";   // TypeError: Assignment to constant variable

const est préférable par défaut : si la valeur ne doit pas changer, autant la verrouiller, le code devient plus sûr et plus lisible. On passe à let quand on doit modifier la valeur.

Choses à ne pas oublier

• La première déclaration définit la variable.
• Elle se déclare une seule fois avec le mot-clé : let age = 20; age = 21; est correct, répéter let age = 21; est une erreur.
• Les noms commencent par lettre, $ ou _, sans tiret ni espace.

Types primitifs

JavaScript distingue, à la base, des types simples :

let texte = "Bonjour";     // string
let nombre = 42;           // number
let vrai = true;           // boolean
let rien = null;           // null (absence volontaire)
let pasAffiche;            // undefined (pas encore donné)
let grandNombre = 10n;     // bigint (les entiers géants, aperçu)
let identifiant = Symbol("cle"); // symbol (aperçu)

Un type détermine ce qu'on peut faire de la valeur. Multiplier deux textes n'a pas de sens :

let total = "a" * "b";     // NaN : Number... Not a Number

Vérifier un type

console.log(typeof 42);      // "number"
console.log(typeof "42");    // "string"
console.log(typeof true);    // "boolean"

Le type est souvent plus fort que la valeur : "42" et 42 ne sont pas interchangeables pour un programme strict : l'un est du texte, l'autre un nombre.

Opérateurs

Arithmétique

console.log(7 + 3);   // 10
console.log(7 - 3);   // 4
console.log(7 * 3);   // 21
console.log(7 / 2);   // 3.5
console.log(7 % 3);   // 1   (reste de la division, dit modulo)

Le % donne le reste : 7 % 3 vaut 1 car 7 = 3 × 2 + 1. Très utile pour tester la parité.

Comparaison

console.log(5 > 3);     // true
console.log(5 < 3);     // false
console.log(5 >= 5);    // true
console.log(5 <= 4);    // false
console.log(5 === 5);   // true    égalité stricte (type + valeur)
console.log(5 === "5"); // false   texte != nombre
console.log(5 !== 6);   // true

On utilise toujours === et !== : l'égalité == fait des conversions implicites et provoque des surprises silencieuses. La distinction est exacte : "" == 0 vaut true avec ==, false avec ===. Toute la communauté JS a abandonné ==.

Logique

console.log(true && false);   // false  (ET : les deux)
console.log(true || false);   // true   (OU : au moins un)
console.log(!true);           // false  (PAS : inverse)

Les opérateurs logiques combinent des booléens (le résultat des comparaisons).

Concaténation de texte

let prenom = "Paul";
console.log("Bonjour " + prenom + " !");          // opérateur +
console.log(`Bonjour ${prenom} !`);               // les backticks : plus lisible

Les backticks (`) forment une chaîne modèle : n'importe quelle expression entre ${ et } est insérée et convertie automatiquement.

Exercice

1. Pour chaque ligne, écrivez d'abord le résultat attendu, puis testez :

let a = 5;
let b = "5";
console.log(a + 1);
console.log(b + 1);
console.log(a === b);
console.log(a == b);   // conversion implicite : pourquoi ?
console.log(typeof b);

2. Déclarez une constante PRIX avec 12, puis une variable quantite avec 3 ; calculez et affichez PRIX * quantite.
3. Affichez le type de PRIX et de quantite.
4. Expliquez pourquoi console.log("50" / 5) vaut 10.

Résumé

• let = modifiable, const = constant, à préférer par défaut.
• Types primitifs : string, number, boolean, null, undefined, bigint, symbol.
• typeof révèle le type.
• Comparaison stricte : === / !== toujours.
• Modulo % : le reste de la division, pratique pour tester la parité.

let a = 5;
let b = "5";
console.log(a + 1);   // 6    (opération)
console.log(b + 1);   // "51" (concaténation)
console.log(a === b); // false (type différent)
console.log(a == b);  // true  (conversion implicite de b en nombre)
console.log(typeof b);// "string"

const PRIX = 12;
let quantite = 3;
console.log(PRIX * quantite);   // 36

console.log(typeof PRIX);          // "number"
console.log(typeof quantite);      // "number"