Opérateurs d'égalité ECMAScript

La détermination de l'égalité entre deux variables est une opération très importante dans la conception de programmes. Lorsqu'il s'agit de valeurs primitives, cette opération est assez simple, mais elle est un peu plus complexe lorsqu'elle implique des objets.

ECMAScript fournit deux ensembles d'opérateurs d'égalité : l'égalité et l'inégalité sont utilisés pour traiter les valeurs primitives, et l'égalité stricte et l'inégalité stricte sont utilisés pour traiter les objets.

Égalité et inégalité

Dans ECMAScript, l'égalité est représentée par les doubles égalités (==), elle retourne true uniquement lorsque les deux opérandes sont égaux. L'inégalité est représentée par l'opérateur exclamation point suivi d'un égalité (!=), elle retourne true uniquement lorsque les deux opérandes ne sont pas égaux. Pour déterminer si deux opérandes sont égaux, ces deux opérateurs effectuent une conversion de type.

Les règles de conversion de type sont les suivantes :

  • Si l'un des opérandes est une valeur Boolean, convertissez-la en valeur numérique avant de vérifier l'égalité. false devient 0, true devient 1.
  • Si l'un des opérandes est une chaîne de caractères et l'autre un nombre, essayez de convertir la chaîne de caractères en nombre avant de vérifier l'égalité.
  • Si l'un des opérandes est un objet et l'autre une chaîne de caractères, essayez de convertir l'objet en chaîne de caractères avant de vérifier l'égalité.
  • Si l'un des opérandes est un objet et l'autre un nombre, essayez de convertir l'objet en nombre avant de vérifier l'égalité.

Lors de la comparaison, cet opérateur suit également les règles suivantes :

  • Les valeurs null et undefined sont égales.
  • Ne pas convertir null et undefined en d'autres valeurs lors de la vérification de l'égalité.
  • Si l'un des opérandes est NaN, l'égalité retourne false, et l'inégalité retourne true.
  • Si les deux opérandes sont des objets, c'est leur valeur de référence qui est comparée. Si les deux opérandes pointent vers le même objet, l'égalité retourne true, sinon les deux opérandes ne sont pas égaux.

Avis important :Même si les deux nombres sont NaN, l'égalité retourne false, car selon les règles, NaN n'est pas égal à NaN.

Le tableau suivant liste quelques cas spéciaux et leurs résultats :

expression valeur
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

Opérateurs égal strict et non strict

Les opérateurs égaux et non égaux sont des opérateurs égaux stricts et non stricts. Ces opérateurs font la même chose que les opérateurs égaux et non égaux, mais ils ne réalisent pas de conversion de type avant de vérifier l'égalité.

L'opérateur égal strict (===) est représenté par trois égales (===). Il retourne true uniquement si les opérandes sont égaux sans conversion de type.

Par exemple :

var sNum = "66";
var iNum = 66;
alert(sNum == iNum); // Affiche "true"
alert(sNum === iNum); // Affiche "false"

Dans ce code, la première alert utilise l'opérateur égal (=) pour comparer la chaîne "66" et le nombre 66, affichant "true". Comme mentionné précédemment, c'est parce que la chaîne "66" est convertie en nombre 66 avant d'être comparée à un autre nombre 66. La deuxième alert utilise l'opérateur égal strict (===) pour comparer une chaîne et un nombre sans conversion de type, bien sûr, la chaîne n'est pas égale au nombre, donc elle affiche "false".

L'opérateur non égal (!==) est représenté par un exclamation point suivi de deux égales (!==). Il retourne true uniquement si les opérandes ne nécessitent pas de conversion de type et ne sont pas égaux.

Par exemple :

var sNum = "66";
var iNum = 66;
alert(sNum != iNum); // Affiche "false"
alert(sNum !== iNum); // Affiche "true"

Ici, la première alert utilise l'opérateur non égal (!==) pour convertir la chaîne "66" en nombre 66, ce qui le rend égal au second opérande 66. Par conséquent, le résultat du calcul est "false", car les deux opérandes sont égaux. La deuxième alert utilise l'opérateur non égal. L'opération pose la question : "sNum" est-elle différente de "iNum" ? La réponse à cette question est : oui (true), car sNum est une chaîne et iNum est un nombre, ils sont naturellement différents.