Notes d'étude Javascript : symbole d'égalité et symbole d'égalité stricte

Ce chapitre présente en détail les symboles d'égalité et les symboles d'égalité stricte en JavaScript. Les amis dans le besoin peuvent s'y référer.

Javascript dispose de deux méthodes pour déterminer si deux valeurs sont égales.

Symbole d'égalité

Le symbole d'égalité est constitué de deux signes égaux : ==
Javascript est un langage faiblement typé. Cela signifie que le symbole d'égalité convertira le type afin de comparer deux valeurs.

""           ==   "0"           // false
0            ==   ""            // true
0            ==   "0"           // true
false        ==   "false"       // false
false        ==   "0"           // true
false        ==   undefined     // false
false        ==   null          // false
null         ==   undefined     // true
" \t\r\n"    ==   0             // true

Le code ci-dessus montre le résultat de la conversion de type, nous savons donc que l'utilisation du symbole d'égalité == est une mauvaise habitude de programmation. En raison du mécanisme complexe de conversion de type en Javascript, les erreurs qui en résultent deviendront difficiles à détecter.

De plus, la coercition de type aura également un certain impact sur les performances. Par exemple, lorsqu'une chaîne est comparée à un nombre, elle sera contrainte en un nombre.

Symbole d'égalité stricte

Le symbole d'égalité stricte se compose de trois signes égaux : ===
Il fonctionne de la même manière que le symbole d'égalité, mais le symbole d'égalité stricte n'effectuera pas d'opération de conversion de type forcée.

""           ===   "0"           // false
0            ===   ""            // false
0            ===   "0"           // false
false        ===   "false"       // false
false        ===   "0"           // false
false        ===   undefined     // false
false        ===   null          // false
null         ===   undefined     // false
" \t\r\n"    ===   0             // false

Le code ci-dessus rend le code plus clair Si les deux valeurs sont de types différents, false est renvoyé directement, ce qui améliorera également les performances.

Comparaison d'objets

Bien que == et === soient appelés symboles d'égalité, lorsque l'une des deux valeurs comparées est un objet, le comportement sera grande différence .

{} === {};                   // false
new String('foo') === 'foo'; // false
new Number(10) === 10;       // false
var foo = {};
foo === foo;                 // true

Ici, il ne s'agit plus seulement de comparer si les deux valeurs sont égales, il déterminera si les deux valeurs font référence à la même instance d'objet. Ce comportement s'apparente davantage à un pointeur dans. C.

Résumé

Il est fortement recommandé de n'utiliser que le symbole d'égalité stricte ===. Si nous devons effectuer une conversion de type, nous pouvons effectuer une conversion de type explicite avant la comparaison au lieu de nous fier à la méthode de conversion complexe de Javascript.

Ce qui précède représente l'intégralité du contenu de ce chapitre. Pour plus de didacticiels connexes, veuillez visiter le Tutoriel vidéo JavaScript !