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.
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
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 === y2. 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
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({}) == +0ToPrimitive({})的结果是字符串"[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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
