JavaScript - Opérateurs de Comparaison

Salut à toi, futurs magiciens JavaScript ! Aujourd'hui, nous allons plonger dans le monde magique des opérateurs de comparaison. Ne t'inquiète pas si tu n'as jamais écrit une ligne de code auparavant - je serai ton guide bienveillant sur ce voyage passionnant. Alors, sers-toi de tes baguettes (je veux dire, claviers), et c'est parti !

Opérateurs de Comparaison JavaScript

Les opérateurs de comparaison sont comme les juges dans le monde de la programmation. Ils regardent deux valeurs et décident comment elles se rapportent l'une à l'autre. Sont-elles égales ? L'une est-elle supérieure à l'autre ? Ces opérateurs nous aident à prendre des décisions dans notre code, tout comme nous le faisons dans la vie réelle.

Voyons tous les opérateurs de comparaison que nous couvrirons aujourd'hui :

Opérateur	Nom	Exemple
==	Égalité	x == y
!=	Inégalité	x != y
===	Égalité Stricte	x === y
!==	Inégalité Stricte	x !== y
>	Supérieur à	x > y
>=	Supérieur ou Égal	x >= y
<	Inférieur à	x < y
<=	Inférieur ou Égal	x <= y

Comment les comparaisons sont effectuées ?

Avant de plonger dans chaque opérateur, comprenons comment JavaScript compare les valeurs. Ce n'est pas trop différent de la manière dont nous comparons les choses dans la vie réelle !

1. Si nous comparons des nombres, c'est simple. JavaScript vérifie quel nombre est plus grand.
2. Pour les chaînes, JavaScript les compare caractère par caractère, en fonction de leurs valeurs Unicode.
3. Si nous comparons des types différents (comme un nombre et une chaîne), JavaScript essaie généralement de convertir un type en l'autre avant de comparer.

Maintenant, voyons chaque opérateur en détail.

Opérateur d'Égalité (==) JavaScript

L'opérateur d'égalité (==) vérifie si deux valeurs sont égales, mais il est un peu flexible. Il peut convertir les types avant de comparer. Voici quelques exemples :

console.log(5 == 5);     // true
console.log(5 == "5");   // true
console.log(true == 1);  // true
console.log(null == undefined);  // true

Dans le premier exemple, il est clair pourquoi nous obtenons true. Dans le second, JavaScript convertit la chaîne "5" en un nombre avant de comparer. Le troisième exemple peut vous surprendre - JavaScript considère true comme 1 et false comme 0. Le dernier exemple montre que null et undefined sont considérés comme égaux avec l'opérateur ==.

Opérateur d'Inégalité (!=) JavaScript

L'opérateur d'inégalité (!=) est comme l'opposé de ==. Il vérifie si deux valeurs ne sont pas égales.

console.log(5 != 6);     // true
console.log(5 != "5");   // false
console.log(true != 1);  // false

Comme ==, il effectue également une conversion de type avant de comparer.

Opérateur d'Égalité Stricte (===) JavaScript

Maintenant, rencontrons l'opérateur d'égalité stricte (===). Cet opérateur est comme le frère aîné strict de ==. Il vérifie non seulement la valeur mais aussi le type.

console.log(5 === 5);     // true
console.log(5 === "5");   // false
console.log(true === 1);  // false
console.log(null === undefined);  // false

Voyez comment les résultats sont différents de == ? L'opérateur d'égalité stricte ne fait aucune conversion de type.

Opérateur d'Inégalité Stricte (!==) JavaScript

L'opérateur d'inégalité stricte (!==) est l'opposé de ===. Il vérifie si deux valeurs ne sont pas égales en valeur ou en type.

console.log(5 !== 6);     // true
console.log(5 !== "5");   // true
console.log(true !== 1);  // true

Opérateur de Supérieur (>)

L'opérateur de supérieur (>) vérifie si la valeur de gauche est supérieure à la valeur de droite.

console.log(10 > 5);   // true
console.log(5 > 10);   // false
console.log(10 > 10);  // false
console.log("b" > "a");  // true (comparaison des valeurs Unicode)

Souviens-toi, lors de la comparaison des chaînes, c'est basé sur leurs valeurs Unicode, pas sur leur ordre alphabétique !

Opérateur de Supérieur ou Égal (>=)

L'opérateur de supérieur ou égal (>=) vérifie si la valeur de gauche est supérieure ou égale à la valeur de droite.

console.log(10 >= 5);   // true
console.log(10 >= 10);  // true
console.log(5 >= 10);   // false

Opérateur d'Inférieur (<)

L'opérateur d'inférieur (<) vérifie si la valeur de gauche est inférieure à la valeur de droite.

console.log(5 < 10);   // true
console.log(10 < 5);   // false
console.log(10 < 10);  // false

Opérateur d'Inférieur ou Égal (<=)

L'opérateur d'inférieur ou égal (<=) vérifie si la valeur de gauche est inférieure ou égale à la valeur de droite.

console.log(5 <= 10);   // true
console.log(10 <= 10);  // true
console.log(10 <= 5);   // false

Comparaison de null, undefined et NaN

Comparer des valeurs spéciales comme null, undefined, et NaN peut être délicat. Voici quelques exemples :

console.log(null == undefined);  // true
console.log(null === undefined);  // false
console.log(NaN == NaN);  // false
console.log(NaN === NaN);  // false
console.log(null > 0);  // false
console.log(null == 0);  // false
console.log(null >= 0);  // true

Le comportement avec null et undefined peut être surprenant. NaN n'est égal à rien, pas même à lui-même ! Et null est converti en 0 dans les comparaisons, mais pas dans les vérifications d'égalité.

Et voilà, les amis ! Nous avons fait le voyage à travers le pays des opérateurs de comparaison JavaScript. Souviens-toi, la pratique rend parfait, donc n'ayez pas peur d'expérimenter avec ces opérateurs dans votre propre code. Bon codage !

Credits: Image by storyset