Comment déterminer si une phase est égale en JavaScript

Comment déterminer l'égalité en JavaScript : 1. Utilisez l'opérateur "==" ou "!==" pour comparer si les valeurs des deux opérandes sont égales ; 2. Utilisez l'opérateur "===" ou " ! ==" symbole de l'opérateur, compare si les valeurs des deux opérandes sont égales et vérifie si leurs types sont les mêmes.

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

JavaScript détermine l'égalité

En JavaScript, vous pouvez utiliser l'opérateur ==、===、!=、!== pour déterminer l'égalité ou l'inégalité

Opérateur de détection d'égalité	Explication
==(Égalité)	Comparez si les valeurs des deux opérandes sont égales
!= (je ne veux pas attendre)	Comparez si les valeurs des deux opérandes ne sont pas égales
=== (Congruent)	Comparez les deux si les valeurs des deux opérandes sont égales et vérifiez si leurs types sont les mêmes
!== (non congruents)	Comparez si les valeurs des deux opérandes ne le sont pas égaux et vérifiez si leurs types ne sont pas les mêmes

Dans l'opération d'égalité, vous devez faire attention aux problèmes suivants :

• Si l'opérande est une valeur booléenne, elle est d'abord convertie en valeur numérique , où false est converti en 0 et true est converti en 1.

• Si un opérande est une chaîne et que l'autre opérande est un nombre, essayez d'abord de convertir la chaîne en nombre.

• Si un opérande est une chaîne et que l'autre opérande est un objet, essayez d'abord de convertir l'objet en chaîne.

• Si un opérande est un nombre et que l'autre opérande est un objet, essayez d'abord de convertir l'objet en nombre.

• Si les deux opérandes sont des objets, comparez les adresses de référence. Si les adresses de référence sont les mêmes, elles sont égales ; sinon elles ne sont pas égales.

Exemple 1

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

console.log("1" == 1);  //返回true。字符串被转换为数字
console.log(true == 1);  //返回true。true被转换为1
console.log(false == 0);  //返回true。false被转换为0
console.log(null == 0);  //返回false
console.log(undefined == 0);  //返回false
console.log(undefined == null);  //返回true
console.log(NaN == "NaN");  //返回false
console.log(NaN ==1);  //返回false
console.log(NaN == NaN);  //返回false
console.log(NaN != NaN);  //返回true

NaN ​​​​n'est égal à aucune valeur, y compris elle-même. Les valeurs nulles et indéfinies sont égales, mais ce sont des types de données différents. Dans les comparaisons d'égalité, null et undefined ne peuvent pas être convertis en d'autres types de valeurs.

Exemple 2

Les valeurs des deux variables suivantes sont égales.

var a = "abc" + "d";
var b = "a" + "bcd";
console.log(a == b);  //返回true

L'opération de comparaison d'égalité des valeurs numériques et booléennes est relativement efficace, tandis que les chaînes doivent être comparées caractère par caractère, et l'efficacité de l'opération de comparaison d'égalité est relativement faible.

Dans les opérations de congruence, 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.

Exemple 3

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 4

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 5

Pour les objets composites, l'adresse de la 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 6

Pour les valeurs simples, tant que les types sont les mêmes et les valeurs sont égales, elles sont congruentes, quels que soient les changements de processus de l'opération d'expression, ni l'adresse de référence de la variable.

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

Exemple 7

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!