Por quê ==
é tão imprevisível?
O que você ganha quando compara uma string vazia ""
com o número zero 0
?
true
Sim, está certo de acordo com ==
uma string vazia e o número zero é ao mesmo tempo.
E não termina aí, aqui está outro:
'0' == false // true
As coisas ficam realmente estranhas com matrizes.
[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true
Então mais estranho com cordas
[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!
Fica pior:
Quando é igual não é 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!
Deixe-me dizer isso de novo:
(A == B) && (B == C) // true
(A == C) // **FALSE**
E este é apenas o material maluco que você recebe com os primitivos.
É um nível totalmente novo de loucura quando você usa ==
objetos.
Neste ponto, você provavelmente está se perguntando ...
Por que isso acontece?
Bem, é porque, ao contrário de "triple equals" ( ===
), apenas verifica se dois valores são iguais.
==
faz um monte de outras coisas .
Possui tratamento especial para funções, tratamento especial para nulos, indefinidos, cadeias, o nome dele.
Fica muito maluco.
De fato, se você tentasse escrever uma função que faça o ==
que seria, seria algo como isto:
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();
}
Então o que isso quer dizer?
Isso significa ==
é complicado.
Por ser complicado, é difícil saber o que acontecerá quando você o usar.
O que significa que você pode acabar com bugs.
Então a moral da história é ...
Torne sua vida menos complicada.
Use em ===
vez de ==
.
O fim.
=== vs ==
, mas em PHP, pode ler aqui: stackoverflow.com/questions/2401478/why-is-faster-than-in-php/…