Qu'est-ce que l'opérateur d'identité javascript ?

En JavaScript, l'opérateur d'identité est "===", qui est utilisé pour comparer si les opérandes des deux côtés de l'équation sont égaux. Lors de l'opération de comparaison, "===" compare non seulement si les valeurs des deux opérandes sont égales, mais vérifie également si leurs types sont les mêmes tant que les valeurs sont égales et que les types sont les mêmes ; , true sera renvoyé.

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3.

En JavaScript, l'opérateur d'identité est "===", qui est utilisé pour comparer si les opérandes des deux côtés de l'équation sont égaux.

Lors d'une opération de comparaison, l'opérateur "===" compare non seulement si les valeurs des deux opérandes sont égales, mais vérifie également si leurs types sont les mêmes.

Dans les opérations d'identité, vous devez faire attention aux problèmes suivants :

• Si les deux opérandes sont des valeurs simples, alors ils sont congrus tant que les valeurs sont égales et que les types sont les mêmes.

• Si un opérande est une valeur simple et que l'autre opérande est un objet composite, ils ne sont pas congruents.

• Si les deux opérandes sont des objets composites, comparez si les adresses de référence sont les mêmes.

(1) Si les types sont différents, ils ne doivent pas être égaux

(2) Si les deux sont des valeurs numériques et qu'elles ont la même valeur, alors elles sont égales si au moins l'une d'elles est NaN ; , alors ils ne sont pas égaux. (Pour déterminer si une valeur est NaN, vous ne pouvez utiliser que isNaN() pour déterminer)

(3) Si les deux sont des chaînes et que les caractères à chaque position sont les mêmes, alors ils sont égaux, sinon ils ne sont pas égaux.

(4) Si les deux valeurs sont vraies ou fausses, alors elles sont égales

(5) Si les deux valeurs font référence au même objet ou fonction, alors elles sont égales, sinon elles ne sont pas égales

( 6) Si les deux valeurs Si les deux valeurs sont nulles ou indéfinies, alors elles sont égales

Exemple 1

Ce qui suit est une comparaison congruente d'opérandes spéciaux.

console.log(null === undefined);  //返回false
console.log(0 === "0");  //返回false
console.log(0 === false);  //返回false

Exemple 2

Ce qui suit est une comparaison de deux objets, qui renvoie vrai puisqu'ils font tous deux référence à la même adresse.

var a = {};
var b = a;
console.log(a === b);  //返回true

Bien que les deux objets suivants aient la même structure, ils ont des adresses différentes, ils ne sont donc pas congruents.

var a = {};
var b = {};
console.log(a === b);  //返回false

Exemple 3

Pour les objets composites, l'adresse de référence est principalement comparée, et la valeur de l'objet n'est pas comparée.

var a = new String("abcd);  //定义字符串“abcd”对象
var b = new String("abcd);  //定义字符串“abcd”对象
console.log(a === b);  //返回false
console.log(a == b);  //返回false

Dans l'exemple ci-dessus, les valeurs des deux objets sont égales, mais les adresses de référence sont différentes, donc ils ne veulent pas attendre et ne sont pas égaux. Par conséquent, pour les objets composites, les résultats des opérations d’égalité == et de congruence === sont les mêmes.

Exemple 4

Pour les valeurs simples, tant qu'elles ont le même type et des valeurs égales, elles sont congruentes, quel que soit le changement dans le processus d'opération d'expression ou l'adresse de référence de la variable.

var a = "1" + 1;
var b = "11";
console.log(a ===b);  //返回true

Exemple 5

L'expression (a>b || a==b) n'est pas exactement égale à l'expression (a>=b).

var a = 1;
var b = 2;
console.log((a > b || a == b) == (a >= b));  //返回true，此时似乎相等

Si null et undefined sont affectés respectivement aux variables a et b, la valeur false est renvoyée, indiquant que les deux expressions ne sont pas complètement équivalentes.

var a = null;
var b = undefined;
console.log((a > b || a == b) == (a >= b));  //返回false，表达式的值并非相等

Parce que null == undefined est égal à true, la valeur de retour de l'expression (a > b || a == b) est vraie, mais la valeur de retour de l'expression null >= undefined est fausse.

【Recommandations associées : Tutoriel d'apprentissage Javascript】

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!