O JavaScript tem duas maneiras de determinar se os dois valores são iguais.
Símbolo igual
O símbolo da igualdade consiste em dois sinais iguais: ==
JavaScript é um idioma do tipo fraco. Isso significa que sinais iguais lançarão o tipo para comparar dois valores.
A cópia do código é a seguinte:
"" == "0" // false
0 == "" // true
0 == "0" // true
false == "false" // false
false == "0" // true
false == indefinido // false
false == null // false
null == indefinido // true
"/t/r/n" == 0 // true
O código acima mostra o resultado da conversão do tipo, por isso sabemos que usar o sinal igual == é um mau hábito de programação. Devido ao mecanismo de conversão do tipo complexo no JavaScript, os erros resultantes se tornarão difíceis de rastrear.
Além disso, a fundição de tipos também pode ter um certo impacto no desempenho, por exemplo, quando uma string é comparada a um número, ela será lançada a um número.
Símbolo de igualdade estrito
Símbolo de igualdade estrito consiste em três sinais iguais: ===
É semelhante à operação de símbolos iguais, mas símbolos estritamente iguais não executarão operações de elenco.
A cópia do código é a seguinte:
"" === "0" // false
0 === "" // false
0 === "0" // false
false === "false" // false
false === "0" // false
false === indefinido // false
false === null // false
null === indefinido // false
"/t/r/n" === 0 // false
O código acima torna o código mais claro. Se os dois valores tiverem tipos diferentes, eles retornarão diretamente falsos, o que também melhorará o desempenho.
Objeto de comparação
Embora == e === sejam chamados de sinais iguais, o desempenho será muito diferente quando um dos dois valores comparado é um objeto.
A cópia do código é a seguinte:
{} === {}; // false
new string ('foo') === 'foo'; // false
novo número (10) === 10; // false
var foo = {};
foo === Foo; // verdadeiro
Aqui, não é mais apenas comparar se os dois valores são iguais, determinará se os dois valores se referem à mesma instância de objeto, que se comporta mais como um ponteiro em C.
Resumir
É fortemente recomendado aqui para usar apenas símbolos rígidos de igualdade ===. Se precisarmos digitar conversão, podemos fazer a conversão de tipo explícito antes da comparação, em vez de confiar no próprio método de fundição do JavaScript.