Explication détaillée du contenu de ==, === et Object.js() en js (complète)

Cet article vous apporte une explication détaillée de ==, === et Object.js() en js (complète). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Cet article explique principalement les trois opérations d'égalité en JavaScript : ==, === et Object.js(). Approfondissez l'impression de chacun à travers des comparaisons et des exemples, et fournissez des explications détaillées sur des exemples individuels.

Connaissances préliminaires

Explication détaillée de la connaissance de l'opération abstraite ToPrimitive dans la spécification ECMAScript7 (exemple)

=== opérateur

Pour x === y, les étapes de comparaison de cet opérateur sont les suivantes :

1 Si le type de x est différent du type de y, renvoie false ; Si le type de x est un nombre , alors :

a Si x est NaN, renvoie false

b Si y est NaN, renvoie false ; . Si x et y sont la même valeur numérique, renvoie vrai

d Si x est +0 et y est -0, renvoie vrai

e. y est +0, renvoie vrai;

f. Renvoie false

3.

L'opération abstraite SameValueNonNumber(x, y) compare deux non-nombres et détermine si x et y du même type sont égaux. Les étapes de comparaison sont les suivantes :

Si le type de. x est nul ou indéfini, renvoie true ;

2. Si x est un type de chaîne,

Si x et y sont exactement la même séquence de codage de caractères, renvoie true, sinon renvoie false ; 🎜>

3 , si x est un type booléen,

4 Si x et y sont tous deux vrais ou faux, retournez vrai, sinon retournez faux ; un type de symbole,

Si x et y sont la même valeur de symbole, renvoie vrai, sinon renvoie faux

6. Si x et y sont la même valeur d'objet, renvoie vrai, sinon renvoie ; FAUX.

Les points à noter sont NaN, +0, -0 :

Ces trois exemples correspondent respectivement à 2.1, 2.4 et 2.5 dans l'étape de comparaison x === y. Les résultats de sortie de ces trois exemples sont tout à fait conformes aux définitions des spécifications. Il n'y a aucune raison, c'est ainsi que les spécifications sont définies. Quant à savoir pourquoi la spécification est définie de cette manière, vous devrez peut-être demander aux créateurs de la spécification. Cela dépasse le cadre de cet article.

Object.is()

Pour Object.is(x, y), l'opération abstraite SameValue(x, y) sera utilisée à des fins de comparaison. Les étapes de cette opération abstraite sont les suivantes. suit :

NaN === NaN // false
+0 === -0 // true
-0 === +0 // true

1. Si le type de x est différent du type de y, renvoie false ;

2. Si le type de x est un nombre, alors :

a. Si x et y sont tous deux NaN, retournez vrai

b Si x est +0 et y vaut -0, retournez

c. y est +0, renvoie false ;

d Si x et y sont la même valeur numérique, renvoie true

e, renvoie false ; résultat de SameValueNonNumber(x, y).

On voit que la différence entre === et Object.is() réside dans le traitement de NaN et du signé 0 :

== opérateur

Pour x == y, les étapes de comparaison de cet opérateur sont les suivantes :

1 Si x et y sont du même type, renvoie le résultat de x === y

2. Si x est nul, y est indéfini, renvoie vrai

3. Si x est indéfini, y est nul, renvoie vrai

NaN === NaN // false
+0 === -0 // true
-0 === +0 // true
Object.is(NaN, NaN) // true
Object.is(+0, -0) // false
Object.is(-0, +0) // false

4. , le type de y est une chaîne de caractères, renvoie le résultat de x == ToNumber(y);

5 Si le type de x est une chaîne et le type de y est un nombre, renvoie le résultat de. ToNumber(x) == y;

6 Si le type de x est un type booléen, renvoie le résultat de ToNumber(x) == y; y est un type booléen, renvoie le résultat de x == ToNumber(y);

8 Si le type de x est une chaîne, un nombre ou un symbole et que le type de y est un objet, renvoie le résultat de x == ToPrimitive(y);

9. Si le type de x est un objet, le type de y est une chaîne, un nombre ou un symbole, et le résultat de ToPrimitive(x) = = y est renvoyé

10.

La méthode ToNumber est utilisée ci-dessus. Les étapes de ToNumber(x) sont les suivantes :

1 Si le type de x est Indéfini, retournez NaN ; . Si le type de x est Null, renvoie +0 ;

3 Si le type de x est un type booléen, renvoie 1 si x est vrai, et +0 si faux ; 4. Si le type de x ;

5. Si le type de x est une chaîne, la chaîne de référence est convertie en nombre. Cet article ne présentera pas ce contenu en détail ; 6. Si le type de x est un symbole, NaN est renvoyé ;

7. Si le type de x est un objet,

a. , indice Number);

b. Return ToNumber(primValue) Le résultat de >First, [] à gauche est un tableau vide, le type est objet et à droite est ![], [] est une valeur vraie, donc le résultat de ![] est faux :

Ensuite, vous passerez à l'étape 7 de l'étape de comparaison x == y qui renvoie le résultat de x == ToNumber(y) , soit :

A partir de l'étape 3 de ToNumber(x), on voit que ToNumber(false) renvoie +0 : ​​

Passez ensuite à l'étape 9 de l'étape de comparaison x == y et renvoie le résultat de la comparaison de ToPrimitive(x) == y :

ToPrimitive([ Le résultat de ]) est la chaîne vide "". , veuillez consulter l'article Opération abstraite ToPrimitive dans la spécification ECMAScript7. Par conséquent, ce qui précède équivaut à :

Passez ensuite à l'étape 5 de l'étape de comparaison x == y et renvoyez le résultat de ToNumber(x) == y :

"" == +0 // => ToNumber("") == +0

由ToNumber操作的第5步可知，ToNumber("")的结果是+0，所以也就是：

+0 == +0 // true

{} == !{}

首先，左边是{}，类型是对象，右边是!{}，{}是真值，所以!{}是false：

{} == !{} // => {} == false

然后同样会走到x == y比较步骤的第7步，返回x == ToNumber(y)的结果，也就是：

{} == false // => {} == ToNumber(false)

由ToNumber(x)的第3步可知，ToNumber(false)返回+0：

{} == ToNumber(false) // => {} == +0

然后走到x == y比较步骤的第9步，返回ToPrimitive(x) == y的比较结果：

{} == +0 // => ToPrimitive({}) == +0

ToPrimitive({})的结果是字符串"[object Object]"，原因请查看文章ECMAScript7规范中的ToPrimitive抽象操作。所以，上面等价于：

"[object Object]" == +0

然后走到x == y比较步骤的第5步，返回ToNumber(x) == y的结果：

"[object Object]" == +0 // => ToNumber("[object Object]") == +0

由ToNumber操作的第5步可知，ToNumber("[object Object]")的结果是NaN，所以也就是：

NaN == +0 // false

所以，[] == ![]的结果是true，{} == !{}的结果是false。可能有人第一次看到[] == ![]的时候，觉得这个的比较结果怎么可能是true。我觉得有时候不要感性的去认识问题，按照规定的运算步骤走一遍，结果是什么就是什么。

总结

本文讲解了JavaScript中的三种相等运算：==，===和Object.js()，希望对大家有所帮助。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!