🤯 == ou === ?

La question la plus déroutante de JavaScript

(« Égaux mais pas égaux… pas égaux mais égaux… JS, c’est toi ? »)

Dans le monde de JavaScript, tout le monde finit par passer par là.
Les débutants y tombent.
Les développeurs expérimentés aussi.

Un jour, innocemment, tu écris ce code :

if (5 == "5") {
  console.log("Égal !");
}

Et ça fonctionne.

Puis tu écris ceci :

if (5 === "5") {
  console.log("Égal !");
}

Et là…
💥 Silence.

C’est à ce moment précis que tu commences à tout remettre en question :

« Est-ce que je me trompe… ou est-ce JavaScript ? »

La réponse :
👉 JavaScript est un peu trop relax.

🧠 Les bases d’abord : comment JavaScript comprend l’égalité ?

JavaScript a deux visions différentes de l’égalité :

L’un dit :

« T’inquiète, je gère. »

L’autre dit :

« Les règles sont les règles. »

😎 Qu’est-ce que == ? (Égalité souple – l’ami trop cool)

L’opérateur == s’intéresse uniquement aux valeurs.
Si les types sont différents, il ne panique pas.

JavaScript dit en gros :

« Attends… je convertis un truc, et on voit après. »

🎯 Exemple simple mais dangereux

5 == "5"

➡️ true

📌 Explication :

• Côté gauche : number
• Côté droit : string

JavaScript dit :

« Je transforme la chaîne en nombre, aucun souci. »

Donc, en interne, il se passe ceci :

5 == Number("5")

➡️ 5 == 5 → true

🤡 Allons plus loin (JavaScript fait son show)

0 == false

➡️ true

😳 Pourquoi ?

Explication :

• false → 0
• 0 == 0 → true

"" == false

➡️ true

Explication :

• "" → 0
• false → 0

JavaScript dit :

« Vous êtes tous les deux zéro. Faites la paix. »

null == undefined

➡️ true

📌 Parce que JS dit :

« Vous êtes tous les deux un peu… vides. »

Mais :

null == 0 // false

🤯
Oui…
Ne cherche pas la logique.
C’est JavaScript.

☠️ Pourquoi == est risqué ?

Parce que :

• Tu penses lire le code correctement
• Mais JavaScript fait de la magie en coulisses
• Et cette magie se transforme souvent en bug

💣 Piège de la vraie vie

let userAge = "0";

if (userAge == false) {
  console.log("Âge non renseigné");
}

➡️ ÇA S’EXÉCUTE 😱

Mais :

• "0" est une chaîne
• false est un booléen

JavaScript dit :

« J’ai converti. Tout va bien. »

Et toi, tu dis :

« Pourquoi ce code s’est exécuté ? »
…et tu passes 20 minutes à déboguer.

🧠 Qu’est-ce que === ? (Égalité stricte – discipline militaire)

L’opérateur === exige deux choses :

1. Même valeur ?
2. Même type ?

Si les deux ne sont pas oui :

❌ « Accès refusé. »

🧪 Exemple clair

5 === "5"

➡️ false

📌 Parce que :

• Valeur identique ✔️
• Type différent ❌

JavaScript ne fait :

• aucune conversion
• aucune interprétation
• aucune surprise

🎯 Résultats fiables

0 === false        // false
"" === false       // false
null === undefined // false

Ce que tu vois est exactement ce que tu obtiens.

⚔️ Comparaison côte à côte

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

0 == false    // true
0 === false   // false

null == undefined   // true
null === undefined  // false

📌 Résumé facile à retenir :

• == → « Je convertis »
• === → « Je vérifie tel quel »

🧪 Cas pratique : données provenant d’un formulaire

Les formulaires HTML renvoient toujours des chaînes de caractères.

let age = "18";

❌ Approche négligée (==)

if (age == 18) {
  console.log("Tu peux entrer");
}

➡️ Ça fonctionne
Mais à qui as-tu fait confiance ?
À JavaScript…

✅ Approche professionnelle (===)

if (Number(age) === 18) {
  console.log("Tu peux entrer");
}

📌 Quelle est la différence ?

• Tu gères la conversion toi-même
• La comparaison est volontaire
• Le code est lisible
• Le risque de bug diminue

🧠 Règle d’or (à mémoriser 🧠)

❗ Fais toi-même les conversions de type. Ne les laisse pas à JavaScript.

Utilise :

Number()
String()
Boolean()

Puis :

utilise ===

❓ Alors… == est-il parfois utilisé ?

Réponse honnête :
👉 99 % du temps, non

Mais il existe un cas rare :

if (value == null) {
  // value est null ou undefined
}

📌 Parce que :

• null == undefined → true
• Avec ===, il faudrait deux vérifications

Mais même ce cas est :

• avancé
• délicat
• risqué pour les débutants

🧠 Pourquoi les professionnels utilisent === ?

Parce que :

✅ Le code est plus lisible
✅ Le débogage est plus rapide
✅ Meilleure compatibilité avec les frameworks
✅ ESLint ne crie pas 😄
✅ Pas de « surprises JavaScript »

🎯 Erreurs courantes

❌ Utiliser == pour la validation de formulaires
❌ Comparer des booléens avec ==
❌ Mélanger 0, "" et false avec ==

🏁 Verdict final : lequel gagne ?

🥇 Grand gagnant : ===

== :

• Trop relax
• Trop optimiste
• Trop surprenant 😅

=== :

• Clair
• Discipliné
• Professionnel

🧠 Résumé légendaire en une phrase

« Si tu compares des valeurs en JavaScript,
utilise ===.
Sinon JavaScript pensera à ta place…
et il se trompe souvent. » 😄🚀