Le code est correct. Le résultat est faux. JavaScript te regarde… et sourit.
Quand on écrit du JavaScript, on a parfois cette impression :
« J’apprends ce langage…
mais on dirait que c’est le langage qui essaie de m’analyser. »
La raison est claire :
la coercition de types, les comparaisons par référence et l’attitude
“je sais mieux que toi” de JavaScript.
Dévoilons tout ça, point par point.
1️⃣ "5" + 1 → "51"
« Je voulais une addition, il s’est mis à discuter. »
"5" + 1
// "51"
Que s’est-il passé ?
L’opérateur + a deux personnalités :
- Il voit des nombres → il fait des maths
- Il voit une chaîne → il concatène des chaînes
JavaScript s’est dit :
« L’un est une string… très bien, tout le monde devient une string. »
String(1) → "1"
"5" + "1" → "51"
📌 Astuce :
Number("5") + 1 // 6
Leçon :+ n’est pas fiable.
Si tu veux faire des maths, c’est toi qui choisis le type.
2️⃣ "5" - 1 → 4
« C’était une string il y a une seconde… maintenant il fait des maths ? »
"5" - 1
// 4
Pourquoi ce comportement différent ?
- L’opérateur
-ne comprend pas les strings - Il les force à devenir des nombres
Number("5") - 1 // 4
📌 Résumé de la personnalité JavaScript :
+→ indécis- * /→ mathématicien
3️⃣ [] == false → true
« À ce stade, JavaScript me fait passer un examen. »
[] == false
// true
Catastrophe étape par étape :
[] → ""
"" → 0
false → 0
0 == 0 → true
📌 Réalité :== ne compare pas vraiment les valeurs —
il essaie d’abord de rendre tout le monde semblable.
❌ À ne pas faire :
if (value == false)
✅ À faire :
if (value === false)
4️⃣ [] == ![] → true
« Là, ça devient personnel. »
[] == ![]
// true
Ce qui s’est passé :
![] → false
[] → ""
"" → 0
false → 0
Résultat :
0 == 0 // true
📌 Leçon :! + == + array = chaos
5️⃣ [1,2] == "1,2" → true
« C’est un tableau ou une chaîne ? Personne ne sait. »
[1,2] == "1,2"
// true
Pourquoi ?
[1,2].toString() // "1,2"
Puis :
"1,2" == "1,2"
📌 Règle d’or :
Ne compare jamais des tableaux avec ==.
Ton cœur en souffrira.
6️⃣ NaN === NaN → false
« Même pas égal à lui-même. »
NaN === NaN
// false
Parce que :
NaNsignifie Not a Number- Il représente un résultat indéfini
- Les choses indéfinies ne se comparent pas
📌 Bon test :
Number.isNaN(value)
❌ À éviter :
value === NaN
7️⃣ typeof NaN → "number"
« C’est là que l’acceptation commence. »
typeof NaN
// "number"
JavaScript dit :
« Oui, ce n’est pas vraiment un nombre…
mais ça appartient quand même à la catégorie des nombres. »
📌 Fait :
C’est l’un des plus vieux bugs de JavaScript
et aujourd’hui, on appelle ça une “feature”.
8️⃣ null == undefined → true
« Séparés, mais traités pareil. »
null == undefined
// true
Mais :
null === undefined
// false
Explication :
==→ « Ils sont tous les deux plus ou moins rien »===→ « Mais ce ne sont PAS la même chose »
📌 Vérification pratique :
value == null
// attrape à la fois null et undefined
(Utile si c’est utilisé consciemment.)
9️⃣ 0.1 + 0.2 !== 0.3
« Même les maths de base sont compliquées ? »
0.1 + 0.2
// 0.30000000000000004
Raison :
- La précision des nombres flottants
- Le système binaire
📌 Solutions :
Math.round((0.1 + 0.2) * 100) / 100
ou :
+(0.1 + 0.2).toFixed(2)
🔟 [] === [] → false
« Les mêmes… mais pas vraiment. »
[] === []
// false
Pourquoi ?
- Les tableaux et objets sont comparés par référence, pas par valeur
let a = [];
let b = a;
a === b // true
📌 Leçon :
Pour les objets,
« même contenu » ≠ « même chose »
🧠 Vérité Finale (À Sauvegarder)
JavaScript ne te trolle pas.
Ses règles sont simplement bien cachées.
Guide de survie :
✅ Utilise ===
❌ Évite ==
🧠 Fais toi-même les conversions de types
🤡 Quand ça devient bizarre, ne dis pas
« je suis nul » — accuse JavaScript d’abord. 😄
