JavaScript a deux façons de déterminer si les deux valeurs sont égales.
Symbole égal
Le symbole d'égalité se compose de deux signes égaux: ==
JavaScript est une langue de type faible. Cela signifie que les signes égaux jetteront le type afin de comparer deux valeurs.
La copie de code est la suivante:
"" == "0" // faux
0 == "" // Vrai
0 == "0" // Vrai
false == "false" // faux
false == "0" // vrai
false == Undefined // Faux
false == null // faux
null == Undefined // Vrai
"/ t / r / n" == 0 // vrai
Le code ci-dessus montre le résultat de la conversion de type, nous savons donc que l'utilisation du signe égal == est une mauvaise habitude de programmation. En raison du mécanisme de conversion de type complexe en JavaScript, les erreurs résultantes deviendront difficiles à suivre.
De plus, la coulée des types peut également avoir un certain impact sur les performances, par exemple, lorsqu'une chaîne est comparée à un nombre, elle sera jetée à un nombre.
Symbole d'égalité strict
Le symbole d'égalité strict se compose de trois signes égaux: ===
Il est similaire au fonctionnement de symboles égaux, mais des symboles strictement égaux n'effectueront pas les opérations de moulage.
La copie de code est la suivante:
"" === "0" // faux
0 === "" // faux
0 === "0" // faux
false === "false" // faux
false === "0" // faux
false === Undefined // faux
false === null // faux
null === Undefined // faux
"/ t / r / n" === 0 // faux
Le code ci-dessus rend le code plus clair. Si les deux valeurs ont des types différents, ils reviendront directement False, ce qui améliorera également les performances.
Objet de comparaison
Bien que == et === soient appelés signes égaux, les performances seront très différentes lorsque l'une des deux valeurs comparées est un objet.
La copie de code est la suivante:
{} === {}; // FAUX
Nouvelle chaîne ('foo') === 'foo'; // FAUX
nouveau nombre (10) === 10; // FAUX
var foo = {};
foo === foo; // vrai
Ici, il ne s'agit plus seulement de comparer si les deux valeurs sont égales, il déterminera si les deux valeurs se réfèrent à la même instance d'objet, qui se comporte plus comme un pointeur dans C.
Résumer
Il est fortement recommandé ici d'utiliser uniquement des symboles d'égalité stricts ===. Si nous devons effectuer une conversion de type, nous pouvons effectuer une conversion de type explicite avant la comparaison, au lieu de compter sur la propre méthode de casting complexe de JavaScript.