Série avancée JavaScript : égalité et comparaison des types

• Opérateur d'égalité

• Opérateur d'égalité stricte

• Objets de comparaison

• Conclusion

JavaScript propose deux façons de déterminer si deux valeurs sont égales.

Opérateur égal

L'opérateur égal est constitué de deux signes égal : ==

JavaScript est un langage faiblement typé, ce qui signifie que l'opérateur égal sera utilisé pour la comparaison Deux les valeurs sont exprimées.

""           ==   "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 tableau ci-dessus montre la conversion de type forcée, qui est la principale raison pour laquelle l'utilisation de == est largement considérée comme une mauvaise habitude de programmation, ce qui peut entraîner des problèmes difficiles à détecter en raison de son règles de conversion complexes.

De plus, la conversion de type forcée entraînera également une consommation de performances. Par exemple, pour comparer une chaîne avec un nombre, elle doit être forcée à un nombre à l'avance.

Opérateur égal strict

L'opérateur égal strict se compose de trois signes égal : ===

Contrairement à l'opérateur égal ordinaire, le L’opérateur d’égalité stricte n’effectue pas de conversion de type.

""           ===   "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

Les résultats ci-dessus sont plus clairs et utiles pour l'analyse du code. Si les deux types d’opérandes sont différents, ils ne sont certainement pas égaux et contribueront à améliorer les performances.

Objets de comparaison

Bien que les opérateurs == et === soient tous deux des opérateurs égaux, lorsque l'un des opérandes est un objet, le comportement est différent .

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

L'opérateur d'égalité compare ici non pas si les valeurs sont égales, mais si elles appartiennent à la même identité ; c'est-à-dire que seule la même instance de l'objet est considérée comme égale. C'est un peu comme en Python et la comparaison de pointeurs en C.

Remarque : Afin de voir la différence entre == et === de manière plus intuitive, veuillez vous référer au tableau d'égalité JavaScript

Conclusion

Il est fortement recommandé d'utiliser l'opérateur égal strict. Si un type doit être converti, cela doit être fait explicitement avant la comparaison, plutôt que d'utiliser les règles de coercition complexes du langage lui-même.

Ce qui précède est la série JavaScript avancée - égalité et comparaison des types. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !