Opérateurs de Comparaison

Vous connaissez les opérateurs de comparaison depuis vos cours de maths, mais rafraîchissons votre mémoire:

L'opérateur 'supérieur à' (a > b) renvoie vrai si l'opérande de gauche est supérieur à l'opérande de droite.

Syntaxe:

a > b

Exemple de l'opérateur 'supérieur à':

Javascript Greater than operator

console.log(7 > 4); // true

L'opérateur 'inférieur à' (a < b) renvoie vrai si l'opérande de gauche est inférieur à l'opérande de droite.

Syntaxe:

a < b

Exemple de l'opérateur 'inférieur à':

Javascript less than operator

console.log(4 < 7); // true

L'opérateur 'supérieur ou égal à' (a >= b) renvoie vrai si l'opérande de gauche est supérieur ou égal à l'opérande de droite.

Syntaxe:

a >= b

Exemple de l'opérateur 'supérieur ou égal à':

jJvascript Greater than or equal operator

console.log(7 >= 4); // true console.log(4 >= 4); // true

L'opérateur 'inférieur ou égal à' (a <= b) renvoie vrai si l'opérande de gauche est inférieur ou égal à l'opérande de droite.

Syntaxe:

a <= b

Exemple de l'opérateur 'inférieur ou égal à':

Javascript less than or equal operator

console.log(4 <= 7); // true console.log(4 <= 4); // true

L'opérateur d'égalité (a == b) convertit les opérandes s'ils ne sont pas du même type, puis applique une comparaison stricte. Si les deux opérandes sont des objets, JavaScript compare les références internes qui sont égales lorsque les opérandes se réfèrent au même objet en mémoire.

Syntaxe:

a == b

Exemple de l'opérateur d'égalité:

Javascript equality operator

console.log(1 == 1); // true console.log("2" == 2); // true console.log(3 == '3'); // true console.log(0 == false); // true console.log(0 == null); // false console.log(0 == undefined); // false console.log(null == undefined); // true

Si les opérandes ne sont pas égaux, l'opérateur d'inégalité (!=) renvoie vrai. Lorsque deux opérandes ne sont pas du même type, JavaScript essaie de convertir les opérandes en un type approprié pour la comparaison.

Si les deux opérandes sont des objets, JavaScript compare les références qui ne sont pas égales, lorsque les opérandes se réfèrent à des objets différents en mémoire.

Syntaxe:

a != b

Exemple de l'opérateur d'inégalité:

Javascript inequality operator

console.log(1 != 2) ; // true console.log(2 != "2"); // false console.log(3 != '3' ); // false console.log(1 != true); // false console.log(0 != false); // false

Booléen est le résultat

Une comparaison renvoie une valeur comme tous les autres opérateurs. La valeur, dans ce cas, est un booléen.

true signifie “oui”, “correct” ou “la vérité”;
false signifie “non”, “falsifié” ou “pas la vérité”.

Comparison operator in javascript

console.log( 3 > 1 ); // true (correct) console.log( 3 == 1 ); // false (wrong) console.log( 3 != 1 ); // true (correct)

Un résultat de comparaison peut être assigné à une variable, comme toute valeur:

Comparison operator javascript

let result = 7 > 4; // the result of the comparison console.log ( result ); // true

Comparaison de chaînes

JavaScript utilise l'ordre “dictionnaire” ou “lexicographique” pour voir si une chaîne est plus grande qu'une autre. En d'autres termes, les chaînes sont comparées lettre par lettre.

Exemple de la comparaison de chaînes:

The string comparison in javascript

console.log( 'Z' > 'A' ); // true console.log( 'Want' > 'Walk' ); // true console.log( 'Too' > 'To' ); // true

Dans les exemples, la comparaison 'Z' > 'A' arrive à un résultat à la première étape alors que les chaînes "Want" et "Walk" sont comparées caractère par caractère:

W est identique à W.
a est identique à a.
n est plus grand que l.

Comparaison de différents types

Pour comparer des valeurs de types différents, JavaScript convertit les valeurs en nombres.

The comparison of different types in javascript

console.log( '3' > 1 ); // true, string '3' becomes a number 3 console.log( '02' == 2 ); // true, string '02' becomes a number 2

Pour les valeurs booléennes , true devient 1, false devient 0.

Comparison of different types in javascript

console.log( true == 1 ); // true console.log( false == 0 ); // true

Égalité stricte

Une vérification d'égalité régulière == a un problème, car elle ne peut pas différencier 0 de false:

The regular equality == in javascript

console.log( 0 == false ); // true

On rencontre la même chose avec une chaîne vide:

The regular equality == in javascript

console.log( '' == false ); // true

Comparaison avec null et undefined

Un comportement non intuitif est lorsque null ou undefined sont comparés à d'autres valeurs. Pour une vérification d'égalité stricte ===. Ces valeurs sont différentes, car chacune d'elles est d'un type différent.

The strict equality === in javascript

console.log( null === undefined ); // false

Pour une vérification non stricte ==

Ces deux sont un “couple charmant”, cela signifie qu'ils sont égaux entre eux.

The regular equality == in javascript

console.log( null == undefined ); // true

La différence entre == et ===

JavaScript a deux façons de tester l'égalité visuellement similaires, mais très différentes:

== (Opérateur égal à double): l'opérateur de comparaison abstraite ou d'égalité

=== (Opérateur égal à triple): l'opérateur de comparaison stricte ou d'identité

Voici les différences entre == et ===:

avant d'afficher la comparaison == convertit les valeurs de variable du même type;
=== ne fait aucune conversion de type et renvoie true uniquement si à la fois les valeurs et les types sont identiques pour les deux variables comparées.

== and === equality in javascript

var val1 = 13; var val2 = 13; console.log(val1 == val2); // true console.log(val1 === val2); // also true

Pour les maths et d'autres comparaisons < > <= >=

Null/undefined sont convertis en nombres, où null devient 0, undefined devient NaN.

Nous vous présentons certaines choses amusantes qui se produisent lorsque nous appliquons ces règles. Et aussi, comment ne pas tomber dans un piège avec elles.

Résultat étrange : null vs 0

Exemple de la comparaison de null avec un zéro:

Compare null with a zero in javascript

console.log( null > 0 ); // (1) false console.log( null == 0 ); // (2) false console.log( null >= 0 ); // (3) true

Mathématiquement, c'est étrange. Le dernier résultat indique que "null est supérieur ou égal à zéro", cela signifie que dans l'une des comparaisons ci-dessus, cela doit être vrai, mais elles sont toutes deux fausses.

La principale raison est qu'une vérification d'égalité == et des comparaisons > < >= <= fonctionnent de manière différente : les comparaisons convertissent null en un nombre, le traitant comme 0. C'est pour cette raison que (3) null >= 0 est vrai et (1) null > 0 est faux.

Mais d'autre part, la vérification d'égalité == pour undefined et null est définie sans aucune conversion. Ils sont égaux entre eux et ne sont égaux à rien d'autre, c'est pour cela que (2) null == 0 est faux.

Un undefined incomparable

On ne peut pas comparer la valeur undefined à d'autres valeurs:

Compare the value with undefined in javascript

console.log( undefined > 0 ); // false (1) console.log( undefined < 0 ); // false (2) console.log( undefined == 0 ); // false (3)

Les raisons pour lesquelles nous obtenons ces résultats sont:

Les comparaisons (1) et (2) renvoient faux, car undefined est converti en NaN. C'est une valeur numérique spéciale qui renvoie faux pour toutes les comparaisons.
La vérification d'égalité (3) renvoie faux, car ici undefined n'est égal qu'à null, undefined et aucune autre valeur.

Heure du Quiz : Testez Vos Compétences!

Prêt à relever le défi de ce que vous avez appris ? Plongez dans nos quiz interactifs pour approfondir votre compréhension et renforcer vos connaissances de manière ludique.