Module 2 -- Types Primitifs et Opérateurs : La Logique de la Nuit

2.1 Les Types : Les Armes du Crime

Le code ment. Les types disent la vérité. Chaque donnée porte une étiquette, un type. Comme savoir si tu tiens un flingue, un couteau, ou juste une photo.

1. `Number` (Les Chiffres Rouges)

Pas de distinction. Entier ou décimal, c'est du sang sur la même feuille.

let âge = 42;           // Un compte rond
let rançon = 50000.99;  // Une somme avec des cendres
let température = -15;  // Un froid qui mord
let coffre = 1e6;       // Un million, écrit comme les initiés
let dette = Infinity;   // L'infini, pour ceux qui n'oublient jamais
let erreur = NaN;       // "Not a Number" - le résultat d'un calcul qui saigne

Le piège : 0.1 + 0.2 === 0.3 retourne false. Les machines trichent. Pour compter l'argent, utilise les centimes.

2. `String` (Les Mots Qui Collent)

Du texte. Des aveux entre guillemets.

let alias = "Le Fantôme"; // Guillemets doubles
let matricule = 'X7B-90';  // Simples, ça revient au même
let confession = `Il a murmuré "fuis"`; // Backticks (`), plus puissants

// Concaténation : coudre des bouts de vérité
let phrase = "Ils cherchent " + alias; // "Ils cherchent Le Fantôme"
// Avec les backticks, on peut tout faire parler :
let rapport = `${alias}, matricule ${matricule}, est en fuite.`;

Échappement : Pour mettre un guillemet dans le mensonge.

let menace = "Il a dit \"Tu es mort\". Je l'ai cru.";

3. `Boolean` (Le Switch Binaire)

true (vrai) ou false (faux). La question ultime. La lumière ou le noir.

let estCoupable = true;
let alibiSolide = false;
let porteVerrouillée = true;

4. `null` et `undefined` : Les Deux Visages du Vide

undefined : "Cette variable n'a jamais eu de valeur". Vide par défaut.

let empreinte;
console.log(empreinte); // undefined. Comme si elle n'avait jamais existé.

null : "Cette variable a été vidée volontairement". Un trou qu'on a creusé.
```
let suspect = null; // On efface la piste. Intentionnellement.
```

La nuance est une corde raide.

5. `Symbol` (Un Aperçu dans l'Ombre)

Un type pour créer des identifiants uniques, impossibles à falsifier. Pour les transactions qu'on veut enterrer.

Le Diagnostiqueur : `typeof`

Ton lampe-torche dans le noir.

console.log(typeof 42);        // "number"
console.log(typeof "Silence"); // "string"
console.log(typeof false);     // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null);      // "object" (⚠️ Un bug historique. Une relique. Null est un type à part.)

2.2 Les Opérateurs : Les Gestes du Métier

Opérateurs arithmétiques (Les Maths du Terrain)

let a = 10, b = 3;

console.log(a + b);   // 13  (Addition)
console.log(a - b);   // 7   (Soustraction)
console.log(a * b);   // 30  (Multiplication)
console.log(a / b);   // 3.333... (Division)
console.log(a % b);   // 1   (Modulo - le reste : 10 / 3 = 3, reste 1)
console.log(a ** b);  // 1000 (Exponentiel : la puissance)

Opérateurs d'affectation (Les Raccourcis Sombres)

let compteur = 5;
compteur += 10; // = compteur + 10 → 15
compteur -= 2;  // → 13
compteur *= 2;  // → 26
compteur /= 2;  // → 13
compteur %= 10; // → 3

Opérateurs de comparaison (L'Interrogatoire)

Ils répondent par true ou false. Un mensonge ou un aveu.

let empreinteA = 5, empreinteB = "5";

console.log(empreinteA == empreinteB);   // true  ⚠️ Compare les VALEURS après conversion
console.log(empreinteA === empreinteB);  // false ✅ Compare VALEUR et TYPE (Égalité stricte)
console.log(empreinteA != empreinteB);   // false ⚠️ Pas égal en valeur ?
console.log(empreinteA !== empreinteB);  // true  ✅ Pas égal en valeur OU en type ?

console.log(empreinteA > 3);    // true
console.log(empreinteA < 10);   // true
console.log(empreinteA >= 5);   // true
console.log(empreinteA <= 5);   // true

LA LOI : Utilise UNIQUEMENT === et !==. Les autres sont des portes dérobées.

Opérateurs logiques (Les Complicités)

&& (ET) : Vrai si les deux complices mentent vrai.
|| (OU) : Vrai si au moins un parle.
! (NON) : Inverse la parole.

let alibiA = true, alibiB = false;

console.log(alibiA && alibiB); // false (true ET false = false)
console.log(alibiA || alibiB); // true  (true OU false = true)
console.log(!alibiA);          // false (l'inverse de true)

// Exemple :
let heure = 14;
let portailOuvert = heure >= 9 && heure <= 18; // vrai si entre 9h et 18h.

Le Ternaire (`? :`) - Le Jugement Express

let âge = 20;
let verdict = âge >= 18 ? "Majeur" : "Mineur";
// (condition) ? valeur si vrai : valeur si faux
// verdict = "Majeur"

L'Opérateur de Coalescence (`??`) - La Porte de Secours

Prend la valeur de droite seulement si celle de gauche est null ou undefined. Pour les valeurs par défaut qui ne trahissent pas.

let nomInformateur = null;
let nomParDéfaut = "Inconnu";

let nomUtilisé = nomInformateur ?? nomParDéfaut;
// nomInformateur est null → on prend nomParDéfaut → "Inconnu"

let compte = 0;
let affichage = compte ?? 100;
// compte est 0 (ni null ni undefined) → on garde 0

2.3 Conversion de Types : Le Jeu des Apparences

JS change les types comme on change d'identité. Parfois utile. Souvent traître.

Conversion explicite (Toi aux commandes)

let plaque = "123";
let chiffre = Number(plaque); // -> 123
let texte = String(456);      // -> "456"
let vérité = Boolean(1);      // -> true

console.log(Number("XYZ")); // NaN (Pas un nombre)
console.log(Boolean(0));    // false
console.log(Boolean("mot"));// true

Conversion implicite (La coercition - Le trucage automatique)

console.log("5" + 3);    // "53"    Le + colle, car il y a une chaîne.
console.log("5" - 3);    // 2       Le - force la conversion en nombre.
console.log("5" * "2");  // 10      Multiplication = conversion.
console.log(5 == "5");   // true    ⚠️ Conversion puis comparaison.
console.log(5 === "5");  // false   ✅ Pas de triche.

Vérité Cachée : "Truthy" et "Falsy"

Quand JS a besoin d'un booléen, il interprète. Certaines valeurs valent false. Les autres, true.

Les 6 valeurs "falsy" (les fausses pistes) :

false
0 (et 0.0, -0)
"" ou '' (chaîne vide)
null
undefined
NaN

if ("") { console.log("passé"); } // Ne passe PAS (chaîne vide = falsy)
if ("Alerte") { console.log("passé"); } // Passe

if (0) { /* rien */ }
if (-1) { /* exécuté */ }
if (undefined) { /* rien */ }

Règles de Survie

=== et !==. Point final.

Pour vérifier une valeur "utile" :

if (maPiste !== undefined && maPiste !== null) {
  // La piste est chaude
}
// Plus court (mais rejette aussi 0 et "" si ce sont des valeurs valides) :
if (maPiste) {
  // Ne rentre pas si maPiste est falsy
}

Pour les valeurs par défaut, ?? est le seul en qui tu peux avoir confiance.

Fin du deuxième round. Tu connais les types, les armes. Tu sais les faire mentir, les comparer, les forcer à parler. La logique est en place. Maintenant, il va falloir l'utiliser.