¿Por qué ==
es tan impredecible?
¿Qué obtienes cuando comparas una cadena vacía ""
con el número cero 0
?
true
Sí, eso es correcto según ==
una cadena vacía y el número cero es al mismo tiempo.
Y no termina ahí, aquí hay otro:
'0' == false // true
Las cosas se ponen realmente extrañas con los arreglos.
[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true
Luego más raro con cuerdas
[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!
Se pone peor:
¿Cuándo es igual no igual?
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!
Déjame decirlo de nuevo:
(A == B) && (B == C) // true
(A == C) // **FALSE**
Y esto es solo lo loco que obtienes con los primitivos.
Es un nivel completamente nuevo de locura cuando lo usas ==
con objetos.
En este punto, probablemente te estés preguntando ...
¿Por qué pasó esto?
Bueno, es porque a diferencia de "triple igual" ( ===
), que solo comprueba si dos valores son iguales.
==
hace un montón de otras cosas .
Tiene un manejo especial para funciones, manejo especial para nulos, indefinidos, cadenas, lo que sea.
Se pone bastante loco.
De hecho, si intentas escribir una función que haga lo que ==
hace, se vería así:
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();
}
Entonces, ¿qué significa esto?
Significa ==
es complicado.
Debido a que es complicado, es difícil saber qué sucederá cuando lo use.
Lo que significa que podrías terminar con errores.
Entonces la moraleja de la historia es ...
Haz tu vida menos complicada.
Usar en ===
lugar de ==
.
El fin.
=== vs ==
, pero en PHP, puede leer aquí: stackoverflow.com/questions/2401478/why-is-faster-than-in-php/…