Comparer des valeurs

Dans un gestionnaire de tâches, vous devez pouvoir répondre à des questions simples : le nombre de tâches terminées est-il supérieur à zéro ? Le texte saisi correspond-il au libellé attendu ? Une liste est-elle vide ? En JavaScript, une comparaison produit une valeur booléenne, true ou false, que vous pourrez ensuite utiliser pour orienter le comportement de la page.

Comparer des nombres et des chaînes

Les opérateurs > et < testent si une valeur est respectivement supérieure ou inférieure à une autre. Leurs variantes >= et <= incluent aussi l’égalité. Avec des nombres, ils permettent par exemple de vérifier si des tâches sont terminées ou s’il en reste à faire. Chaque expression de comparaison renvoie un booléen, que vous pouvez afficher directement pour en examiner le résultat.

const nombreDeTaches = 5;
const nombreDeTachesTerminees = 2;

console.log(nombreDeTachesTerminees > 0);
console.log(nombreDeTachesTerminees < nombreDeTaches);
console.log(nombreDeTachesTerminees >= 2);
console.log(nombreDeTaches <= 5);

const libelleSaisi = "Préparer le repas";
const libelleAttendu = "Préparer le repas";
console.log(libelleSaisi === libelleAttendu);
console.log(libelleSaisi !== "Faire les courses");

true
true
true
true
true
true

Dans cet exemple, chaque comparaison est affichée séparément. Les quatre premières portent sur des nombres ; les deux dernières vérifient l’égalité ou la différence entre des chaînes. Une comparaison de chaînes est sensible aux caractères : une majuscule, un espace ou une ponctuation différente peut rendre les valeurs différentes. Dans la leçon précédente, vous avez vu les types et les valeurs ; ici, vous observez comment une comparaison transforme deux valeurs en un résultat booléen.

Choisir l’égalité stricte

Pour tester si deux valeurs sont égales, utilisez ===. Cet opérateur vérifie à la fois la valeur et son type : le nombre 3 n’est donc pas égal à la chaîne "3". Pour tester une différence, utilisez !==. Ces opérateurs rendent vos comparaisons explicites et évitent qu’une conversion implicite ne masque une différence entre les données. Prenez le réflexe d’utiliser === plutôt que == pour vérifier une égalité.

const nombreSaisi = 3;
const texteSaisi = "3";

console.log(nombreSaisi === 3);
console.log(texteSaisi === 3);
console.log(texteSaisi !== 3);

true
false
true

Le deuxième résultat est false : même si les deux valeurs semblent représenter le chiffre trois, l’une est une chaîne et l’autre un nombre. Le troisième résultat est true, car ces valeurs ne sont pas strictement égales. Dans le gestionnaire, cette distinction vous aidera à comparer des données dont le type est connu, plutôt qu’à compter sur une conversion automatique.

Combiner des comparaisons

Les opérateurs logiques combinent des valeurs booléennes. && renvoie true seulement si les deux côtés sont vrais : vous pouvez l’utiliser pour vérifier qu’il existe des tâches et qu’au moins une est terminée. || renvoie true si au moins un côté est vrai. Enfin, ! inverse un résultat : !true vaut false, et !false vaut true.

const nombreDeTaches = 5;
const nombreDeTachesTerminees = 2;
const aucuneTache = nombreDeTaches === 0;
const auMoinsUneTerminee = nombreDeTachesTerminees > 0;

console.log(nombreDeTaches > 0 && auMoinsUneTerminee);
console.log(aucuneTache || auMoinsUneTerminee);
console.log(!aucuneTache);

true
true
true

Les expressions combinées restent des valeurs, elles ne déclenchent pas encore une action. Vous savez maintenant établir, par exemple, qu’une liste contient des tâches et qu’au moins une est terminée. Dans la prochaine leçon, vous utiliserez de telles expressions avec if et else pour choisir le comportement à exécuter.

À retenir

• Une comparaison renvoie toujours un booléen : true ou false.
• Utilisez >, = et <= pour comparer des nombres.
• Préférez === et !== pour comparer des valeurs sans confondre leur type.
• Combinez les résultats avec &&, || et ! pour exprimer une vérification composée.