Une brève discussion sur l'opérateur d'égalité en JavaScript : la différence entre == et ===

Dans le processus de programmation, nous rencontrons souvent la situation de juger si deux variables sont égales. ECMAscript fournit deux opérateurs d'égalité "==" et "===" Pour juger, les deux. les opérations renverront une valeur booléenne. De manière générale, nous appelons "==" égal et "===" congruent.

Lorsque les types de données des deux variables comparées sont cohérents, la situation est relativement simple. Cependant, lorsque les types de variables des deux côtés de l'opérateur sont incohérents, ou même que l'une des variables est un objet, le La situation est plus compliquée. Comme suit Présentez séparément ce qui arrivera aux résultats de l'opération lorsque les types d'opérandes sont différents.

Le cas de l'opérateur de congruence « === »

L'opérateur de congruence « === » est relativement simple. Lorsque vous utilisez l'opérateur de congruence "===" pour juger, vérifiez d'abord si les types de données des deux côtés de l'opérateur sont cohérents, s'ils sont incohérents, false sera renvoyé directement. Sinon, l'étape suivante du jugement le sera. être fait.

S'il s'agit d'une comparaison de deux booléens, alors les deux côtés de "===" doivent être vrais ou faux avant de pouvoir renvoyer vrai, sinon il renverra faux si les deux comparaisons sont des nombres, alors. seulement si True sera renvoyé uniquement lorsque les deux nombres sont de taille égale, sinon false sera renvoyé.

Si les deux variables à comparer sont des chaînes, comparez d'abord les longueurs des deux chaînes pour voir si elles sont égales. Si les longueurs sont différentes, renvoyez false. Si elles sont égales, commencez par la première. les deux variables. Les caractères commencent à être comparés pour l'égalité et continuent jusqu'au dernier chiffre ; si l'un des chiffres ne veut pas attendre, false est renvoyé, sinon true est renvoyé.

(Remarque : les comparaisons de chaînes n'ignoreront pas les espaces, donc lorsque vous comparez deux chaînes pour voir si elles sont égales, pour garantir la sécurité, vous devez d'abord supprimer les espaces, puis convertir les deux chaînes en majuscules ou minuscules, puis comparer).

Et null ne retournera true que si null===null, sinon il retournera false De même, undefined ne retournera true que si undefined===undefined, sinon il retournera false . Par exemple :

true === 1    //false
"1" === 1    //false
 
//boolean的比较
true === true  //true
true === false  //false

//string的比较
"hello" === "helloworrld" //false
"hello" === "world" //false
"hello" === " hello" //false
"hello" === "hellO" //false
"hello" === "hello" //true

//number的比较
1 === 1  //true
1 === 1.0 //true
1 === 1.2 //false

//null和undefined的比较
undefined === undefined  //true
null === null       //true
undefined === null    //false,两者在"=="时才返回true

Si les deux opérandes pour la comparaison "===" ne sont pas des valeurs de type de base, mais deux objets, la base du jugement à ce stade est de juger si les deux variables sont "les mêmes" Object

var a,b,c;
a = b = {
	name : '柳轻侯',
	city : '南京'
};
c = {
	name : '柳轻侯',
	city : '南京'
};
a === b   //true
a === c   //false

Il ne suffit pas que deux objets « se ressemblent ». a et c sont tous deux des instances d'Object, et ils ont les mêmes propriétés et valeurs, mais ce ne sont pas le « même » objet, car. a et c pointent en fait vers deux instances différentes, donc les deux objets ne sont pas congruents.

Mais a et b pointent vers le même objet. En d'autres termes, a et b sont des alias différents du même objet. Ils pointent en fait exactement vers le même objet, donc a === b. Les règles de comparaison pour "!==" et "===" sont les mêmes et ne seront pas répétées ici.

Opérateur d'égalité "=="

Opérateur de congruence Lors du jugement, si les types des deux variables sont différents, alors renvoie directement faux , mais contrairement à cela, lorsque l'opérateur d'égalité "==" juge, si les types des deux variables sont différents, une conversion de type implicite sera effectuée pour convertir les deux valeurs à comparer dans les mêmes types. comparé à nouveau, alors quelles sont les règles de conversion ?

Lors de la conversion de différents types de données, les opérateurs d'égalité et d'inégalité suivent les règles de base suivantes

• Si l'un des opérandes est une valeur booléenne, il sera comparé avant comparaison La valeur booléenne est converti en valeur numérique, vrai est converti en 1 et faux est converti en 0 ;
• Si l'un des opérandes est de type chaîne et l'autre est de type nombre, le type de chaîne est converti en nombre avant comparaison Le type est ensuite jugé ;
• Indéfini et null ne seront pas convertis en d'autres valeurs pour comparaison avant comparaison ;
• Si l'un des opérandes est un objet et l'autre est un valeur de type de base , puis l'objet est converti en valeur de type de base avant la comparaison, puis les comparaisons suivantes sont effectuées selon les règles précédentes

Les deux opérandes suivent les règles suivantes lors de la comparaison

 ;

• undefined et null sont égaux, c'est-à-dire : undefined == null;
• Si un opérande est NaN, alors false est renvoyé Même si les deux opérandes sont NaN, false sera renvoyé ;
• Si les deux opérandes sont des objets, les règles de comparaison sont les mêmes que les règles de comparaison de "===". Sauf si les deux opérandes sont le même objet, il renvoie vrai, sinon il renvoie faux ;
.

Il convient de noter ici que NaN == NaN renvoie false. NaN ne signifie pas un nombre, ce qui signifie que l'opérande est un non-nombre. Ce non-nombre est incertain. et peut même ne pas être exprimée à l'aide de la syntaxe JavaScript. Une telle quantité inconnue ne peut pas être utilisée pour des comparaisons spécifiques. Si vous ne pouvez pas déterminer quelle est sa valeur pour deux choses inconnues, vous ne pouvez bien sûr pas dire NaN == NaN.

Donc puisqu'on ne peut pas utiliser "==" pour comparer, comment déterminer si une variable est NaN ? Puisqu'on ne peut pas utiliser l'égalité pour déterminer, autant faire l'inverse et utiliser "!=" Déterminer si une variable n'est pas égale à NaN. Par exemple :

//如果需要判定一个变量是不是NaN,可以如下
//a是你需要判定的变量
if((typeof a === "number") && a != NaN ){  //此处需要注意，NaN也是number类型
	//TODO 
}

Situations de comparaison courantes et leurs résultats

null == undefined  // true 
"NaN" == NaN    // false 
5 == NaN      // false 
NaN == NaN     // false 
NaN != NaN     // true 
false == 0     // true 
true == 1      // true 
true == 2      // false 
undefined == 0   // false 
null == 0      // false
"5" == 5      // true

Analyse d'exemples typiques

![] == [] //true

这是一道比较容易令人困惑的题，按照正常的思维模式，对一个操作数逻辑取反，跟这个操作数本身的值是相对的，如果这个操作数本身的值是true,那么取反之后就是false，反之，如果这个操作数的值是false，那么对其逻辑取反之后就是true，无论如何也不会是同一个值，可是事实上却是![] == []。

首先，![]的值是false，因为这里[]被当成了一个数组的实例，是一个对象，而对象都是真值，对其取反，得到一个假值，也就是false。

其次看等号右边，[]是一个对象，要将其转为基本类型值，会先调用数组的valueOf方法，而数组的valueOf方法返回数组本身，没有得到一个基本值。

这时候要继续调用数组的toString方法，得到一个””空字符串，所以这时候也就变成了false == “”是否为真的问题了，而根据前面的规则，如果有一个操作数为boolean值，会将其转为数值，false转化为0。

进而，问题转化为0 == “”是否为真值的问题，当number和string比较时，会将string转为number，而””会转为0。最后，问题变演化成了0 == 0是否为真值，毋庸置疑，结果是true。

这里要注意的就是![]，它被当成了一个整体的逻辑值，是直接对对象进行取反，是一个假值，而不是先把[]转化为基本值再取反

小结

“==”在比较不同类型值得时候会进行隐式的类型转化，而”===”不会转化，全等一定相等，相等却不一定全等，这是一个充分不必要条件。

undefined和null相等而不全等，且在相等比较的时候不会转化为其他类型的值。NaN是不等于NaN 的，要判断某个变量是不是NaN，要用”!=”。对象和非对象在进行比较的时候会先转为基本类型值然后再根据上面的规则进行比较。

推荐教程：《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!