Vérifier l'égalité des chaînes en JavaScript

1. Quand utiliser un opérateur pour l’égalité des chaînes en JavaScript
2. Comprendre l’égalité des chaînes en JavaScript avec des exemples

En JavaScript, il existe quatre opérateurs que vous pouvez utiliser pour vérifier l’égalité des chaînes. Ces opérateurs sont appelés opérateurs de comparaison.

1. Égalité stricte (===) : L’égalité stricte (également appelée opérateur triple égal) vérifie la valeur de la variable et son type de données. Si ces deux choses sont égales, alors il ne renvoie que true, sinon il renvoie false.
2. Strict non égal (!==): C’est l’opposé de Strict égal. Si la valeur ou le type de données ne correspond pas, il renvoie true ; sinon, false.
3. Égal (==) : Le double signe égal vérifie uniquement la valeur d’une variable. Si la valeur correspond, elle renvoie true, sinon elle renvoie false. Il ne se soucie pas du type de variable.
4. Pas égal (!=): C’est l’opposé d’Égal (==). Il ne renvoie true que si les valeurs à l’intérieur des variables ne correspondent pas, quel que soit leur type de données. Si les valeurs correspondent les unes aux autres, il renvoie false.

Ces opérateurs sont utilisés non seulement pour vérifier l’égalité des chaînes, mais également pour vérifier l’égalité d’autres types de données. Parmi ces quatre opérateurs, trouvons le meilleur pour vérifier l’égalité des chaînes en fonction des cas d’utilisation.

Vous avez peut-être déjà vu le 3e et le 4e opérateur, c’est-à-dire == et !=, qui sont également assez courants dans d’autres langages de programmation. Mais la façon dont cela fonctionne en JavaScript est un peu différente de celle des autres langages.

Quand utiliser un opérateur pour l’égalité des chaînes en JavaScript

En lien avec JavaScript, voici quelques cas d’utilisation où vous pouvez utiliser l’un des opérateurs === ou ==.

• Si une valeur en comparaison peut être une valeur true ou false, utilisez === et non ==.
• Si une valeur de comparaison peut être l’une de ces valeurs spécifiques (0, "", ou [] – tableau vide), utilisez === au lieu de ==.
• Dans tous les autres cas, vous pouvez utiliser == en toute sécurité. Ce n’est pas seulement sûr, mais cela simplifie également votre code et améliore la lisibilité.

Les mêmes règles ci-dessus sont applicables lors de l’utilisation des opérateurs Strict non égal (!==) et Différent (!=). Pour en savoir plus sur les règles spécifiques, vous pouvez lire la section 11.9.3 de la spécification ES5.

Comprendre l’égalité des chaînes en JavaScript avec des exemples

Prenons quelques exemples et comprenons ces choses en détail.

Dans cet exemple, nous avons pris deux variables, name_1 et name_2. Les deux prennent "adam" comme valeur de chaîne. Appliquons maintenant chacun des opérateurs ci-dessus et voyons la sortie que nous obtenons.

Ici, nous avons utilisé quatre instructions if et else, chacune représentant différents opérateurs de comparaison. Étant donné que la valeur et le type de données sont les mêmes pour les variables name_1 et name_2, le triple égal ou l’opérateur égal strict (===) affichera True comme sortie. Et le double égal == affichera également True, puisque les deux variables ont les mêmes valeurs.

let name_1 = 'adam';
let name_2 = 'adam';

// Strict Equal
if (name_1 === name_2)
  console.log('True');
else
  console.log('False');

// Equal
if (name_1 == name_2)
  console.log('True');
else
  console.log('False');

// Strict not equal
if (name_1 !== name_2)
  console.log('True');
else
  console.log('False');

// Not equal
if (name_1 != name_2)
  console.log('True');
else
  console.log('False');

Production:

True
True
False
False

Lorsque vous utilisez l’opérateur Strict différent (!==) et l’opérateur différent (!=), ils afficheront tous les deux False comme sortie puisque la valeur elle-même est la même dans les deux variables.

Vous trouverez ci-dessous un autre exemple où nous comparerons une chaîne avec un entier. Ici, nous avons une variable str avec une valeur de "80", une valeur de chaîne. Nous avons une autre variable, num, qui contient une valeur entière de "80". Étant donné que ces deux variables ont les mêmes valeurs avec des types de données différents, voyons ce qui se passe lors de l’utilisation des différents opérateurs de comparaison sur elles.

let str = '80';
let num = 80;

// Strict Equal
if (str === num)
  console.log('True');
else
  console.log('False')

  // Equal
  if (str == num) console.log('True');
else console.log('False')

// Strict not equal
if (str !== num) console.log('True');
else console.log('False')

// Not equal
if (str != num) console.log('True');
else console.log('False')

Production:

False
True
True
False

Comme dans le premier exemple, nous avons également quatre instructions if et else, chacune représentant des opérateurs de comparaison différents.

Lorsque nous utilisons des égalités strictes ou triples (===), nous obtenons False comme sortie. La raison en est que le type de données est différent même si les valeurs sont les mêmes. Mais lorsque nous utilisons le double égal (==), nous obtenons True comme sortie car le double égal vérifie uniquement la valeur et non le type.

Et lorsque nous utilisons Strict not equal (!==), nous obtenons True comme sortie car la valeur de chaîne "80" n’est pas égale à la valeur entière 80; par conséquent, il renvoie True.

Enfin, l’opérateur différent (!=) compare uniquement la valeur des deux variables. Les valeurs doivent être différentes pour imprimer True. Comme les valeurs sont les mêmes dans ce cas, il renvoie False.