Pourquoi ==
est-ce si imprévisible?
Qu'obtenez-vous lorsque vous comparez une chaîne vide ""
avec le nombre zéro 0
?
true
Oui, c'est vrai selon ==
une chaîne vide et le nombre zéro sont en même temps.
Et ça ne s'arrête pas là, en voici un autre:
'0' == false // true
Les choses deviennent vraiment étranges avec les tableaux.
[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true
Puis plus bizarre avec des cordes
[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!
Ça s'empire:
Quand est égal pas égal?
let A = '' // empty string
let B = 0 // zero
let C = '0' // zero string
A == B // true - ok...
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!
Permettez-moi de le répéter:
(A == B) && (B == C) // true
(A == C) // **FALSE**
Et ce ne sont que les trucs fous que vous obtenez avec les primitives.
C'est un tout nouveau niveau de fou lorsque vous l'utilisez ==
avec des objets.
À ce stade, vous vous demandez probablement ...
Pourquoi cela arrive-t-il?
Et bien c'est parce que contrairement à "triple equals" ( ===
) qui vérifie juste si deux valeurs sont identiques.
==
fait tout un tas d'autres trucs .
Il a un traitement spécial pour les fonctions, un traitement spécial pour les valeurs nulles, non définies, les chaînes, vous l'appelez.
C'est assez farfelu.
En fait, si vous essayez d'écrire une fonction qui fait quoi, ==
cela ressemblera à ceci:
function isEqual(x, y) { // if `==` were a function
if(typeof y === typeof x) return y === x;
// treat null and undefined the same
var xIsNothing = (y === undefined) || (y === null);
var yIsNothing = (x === undefined) || (x === null);
if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);
if(typeof y === "function" || typeof x === "function") {
// if either value is a string
// convert the function into a string and compare
if(typeof x === "string") {
return x === y.toString();
} else if(typeof y === "string") {
return x.toString() === y;
}
return false;
}
if(typeof x === "object") x = toPrimitive(x);
if(typeof y === "object") y = toPrimitive(y);
if(typeof y === typeof x) return y === x;
// convert x and y into numbers if they are not already use the "+" trick
if(typeof x !== "number") x = +x;
if(typeof y !== "number") y = +y;
// actually the real `==` is even more complicated than this, especially in ES6
return x === y;
}
function toPrimitive(obj) {
var value = obj.valueOf();
if(obj !== value) return value;
return obj.toString();
}
Qu'est-ce que cela signifie?
Cela signifie que ==
c'est compliqué.
Parce que c'est compliqué, il est difficile de savoir ce qui se passera lorsque vous l'utiliserez.
Ce qui signifie que vous pourriez vous retrouver avec des bugs.
La morale de l'histoire est donc ...
Rendez votre vie moins compliquée.
Utilisez ===
au lieu de ==
.
La fin.
=== vs ==
, mais en PHP, peut lire ici: stackoverflow.com/questions/2401478/why-is-faster-than-in-php/…