🧠 Les opérateurs de comparaison et logiques en JavaScript

(Le centre de rééducation pour ceux qui disent : « Ce if fonctionnait hier… ») 😄

Écrire du JavaScript ressemble parfois à ça :

« Je l’ai dit très clairement,
mais JavaScript a compris tout autre chose. »

Pourquoi ?

À cause des règles de comparaison et de logique.

JavaScript n’est pas stupide — il est simplement trop flexible.
Transformons cette flexibilité en avantage.

🔍 1. Les opérateurs de comparaison

« Sommes-nous identiques, similaires, ou juste une coïncidence ? »

🟡 == (Égalité lâche – mode « ignore le type »)

5 == "5"      // true
true == 1     // true
false == 0    // true

Que se passe-t-il ici ?

JavaScript dit :

« Attends… je vais d’abord les convertir dans le même type. »

Donc :

• "5" → est converti en nombre
• puis comparé

❌ Où est le problème ?

Ce comportement crée des bugs imprévisibles.

📌 Règle :
== ne te ment pas — il est juste trop indulgent.

🟢 === (Égalité stricte – « relation sérieuse »)

5 === "5"   // false
5 === 5     // true

Ici, JavaScript demande :

• Les valeurs sont-elles identiques ?
• Les types sont-ils identiques ?

Si les deux réponses ne sont pas oui → false

📌 Réflexe professionnel :
Utilise ===, adosse-toi et respire.

🔴 != et !== (Différent)

5 != "5"    // false
5 !== "5"   // true

• != → « Ne sommes-nous pas similaires ? »
• !== → « Ne sommes-nous pas la même personne ? »

🎯 Dans la vraie vie :
Utilise !==, évite le drama.

📏 Comparaisons supérieur / inférieur

10 > 5     // true
4 < 2      // false
8 >= 8     // true

Mais…

"10" > 2   // true 😐

Pourquoi ?

JavaScript :

• Convertit "10" en nombre
• Puis compare

📌 Astuce :
Avant de comparer, contrôle les types toi-même — ne laisse pas JavaScript décider.

🧠 2. Les opérateurs logiques

« Quand il y a plusieurs conditions, ça devient sérieux. »

🔗 && (ET)

« On discute seulement si tout est vrai. »

let age = 22;
let license = true;

if (age >= 18 && license) {
  console.log("Tu peux conduire 🚗");
}

Logique :

• Le côté gauche est-il vrai ?
• Le côté droit est-il vrai ?
• Les deux sont-ils vrais ?

📌 Règle :
S’il y en a un seul de faux → résultat faux

⚡ Détail du short-circuit :

false && console.log("ne s’exécutera pas");

La partie droite ne s’exécute jamais.
JavaScript dit :

« C’est déjà faux, pourquoi continuer ? »

🔀 || (OU)

« Un seul suffit, inutile d’insister. »

let admin = false;
let editor = true;

if (admin || editor) {
  console.log("Accès accordé 🔓");
}

Logique :

• Si la gauche est vraie → on s’arrête
• Sinon, on regarde la droite

📌 Astuce en or (très utilisée) :

let name = userName || "Invité";

Si userName est :

• vide → "Invité"
• rempli → sa propre valeur

🔄 ! (NON)

« L’opérateur de psychologie inversée. »

let isLoggedIn = false;

if (!isLoggedIn) {
  console.log("Tu dois te connecter 🔐");
}

Qu’a-t-il fait ?

• false → devient true
• true → devient false

📌 La légende du double point d’exclamation :

!!"hello"  // true
!!0        // false

👉 Le moyen le plus court de convertir une valeur en booléen

⚠️ 3. Truthy & Falsy

« Tout le monde ne dit pas la vérité en JavaScript. »

❌ Valeurs falsy :

false
0
""
null
undefined
NaN

Elles sont considérées comme false dans un if.

✅ Tout le reste est truthy :

"0"      // true
[]       // true
{}       // true
"false"  // true (c’est là que l’ironie commence)

📌 Piège pour débutants :

if (age) {
  // Si age = 0, ce code NE s’exécutera PAS
}

✅ Approche plus sûre :

if (age !== undefined && age !== null) {
}

🧪 4. Scénarios de la vie réelle

🛒 Vérification du panier

if (cart.length > 0 && userLoggedIn) {
  checkout();
}

🧠 Explication :

• Le panier est-il vide ?
• L’utilisateur est-il connecté ?

Si les deux sont vrais → paiement lancé

🔐 Vérification des rôles

if (role === "admin" || role === "moderator") {
  openPanel();
}

Un seul suffit → accès accordé

🧯 5. Erreurs les plus courantes (et comment s’en sortir)

❌ Utiliser ==
❌ Laisser JS gérer la conversion de types
❌ Écrire des if sans connaître truthy/falsy
❌ Confondre 0, "" et null

✅ Utilise ===
✅ Vérifie explicitement
✅ Tu contrôles le code — pas JavaScript

🧠 Leçon finale (en or)

Écrire des if en JavaScript,
ce n’est pas seulement écrire des conditions.

C’est dire à JavaScript exactement ce que tu veux dire.

Plus tu es clair·e :

• moins de bugs
• moins de « pourquoi ça n’a pas marché ? »
• plus de « wow, ce code est propre » 😌

🚀