Comparaison en

À propos de Comparaison

Compare des nombres

En JavaScript, on peut comparer des nombres à l'aide des opérateurs relationnels et d'égalité suivants.

Le résultat de la comparaison est toujours une valeur booléenne, donc soit true, soit false.

1 < 3;
// => true

2 !== 2;
// => false

1 === 1.0;
// => true
// All numbers are floating-points, so this is different syntax
// for the exact same value.

Compare des strings

En JavaScript, les opérateurs de comparaison ci-dessus peuvent aussi servir à comparer des strings. Dans ce cas, c'est l'ordre du dictionnaire (lexicographique) qui s'applique. Tu peux trouver la liste de l'ordre exact de tous les caractères ici.

'Apple' > 'Pear';
// => false

'a' < 'above';
// => true

'a' === 'A';
// => false

Il faut faire attention quand on compare deux variables qui semblent contenir des valeurs numériques mais qui sont de type string. À cause de l'ordre du dictionnaire, le résultat ne sera pas le même que si on comparait des valeurs de type Number.

10 < 2;
// => false

'10' < '2';
// => true (because "1" comes before "2")

Une autre façon de comparer des strings est la méthode localeCompare. Elle permet de définir diverses options pour ajuster la façon dont les strings sont comparés.

L'égalité stricte

Tu te demandes peut-être pourquoi il y a trois signes égaux pour tester l'égalité en JavaScript. === correspond au test d'égalité stricte : aucune conversion de type n'est effectuée et des valeurs de types différents ne sont jamais égales.

'3' === 3;
// => false
// The value on the left has type string, the value on the right
// has type number.

1 === 1n;
// => false
// The value on the left has type number, the value on the right
// has type bigint.

Utiliser === et !== est la façon recommandée de tester l'égalité en JavaScript.

Évite les conversions de type implicites

Il existe aussi == et !=, qui correspondent au test d'égalité faible. Tu dois l'éviter, car il applique une conversion de type implicite avant d'effectuer la comparaison. Dans ces cas-là, les résultats sont difficiles à prévoir et parfois différents de ce que tu attends. Tu peux en lire plus ici.

0 == false;
// => true

En théorie, on peut aussi comparer des valeurs de types différents (par exemple, "1" < 2). Les valeurs sont alors converties implicitement pour déterminer si le résultat est vrai ou faux. Tout comme le test d'égalité faible, ce n'est pas recommandé, pour la même raison que celle mentionnée plus haut.

Que faire à la place ? Tu peux appliquer une conversion de type explicite. Ainsi, tu peux t'assurer que les valeurs ont le bon type avant d'effectuer la comparaison. Ton code sera alors plus facile à comprendre et moins sujet aux erreurs.