Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
JavaScript

Les opérateurs de comparaison et logiques (== et ===)

Les opérateurs de comparaison et logiques (== et ===). Dans cette leçon du cours JavaScript, vous apprendrez à : comparer des valeurs et obtenir un booléen ; comprendre la différence entre == et === ;...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Les opérateurs de comparaison et logiques (== et ===). Dans cette leçon du cours JavaScript, vous apprendrez à : comparer des valeurs et obtenir un booléen ; comprendre la différence entre == et === ; combiner des conditions avec &&, || et ! ; connaître les valeurs falsy, le court-circuit et l'opérateur conditionnel ? :.

Chapitre 3 — Les variables, les types et les opérateurs · Les opérateurs de comparaison et logiques (== et ===)

🎯 Objectifs de la leçon
• comparer des valeurs et obtenir un booléen ;
• comprendre la différence entre == et ===;
• combiner des conditions avec &&, || et !;
• connaître les valeurs falsy, le court-circuit et l'opérateur conditionnel ? :.

1. Les opérateurs de comparaison

Une comparaison produit toujours un booléen: true ou false. Ces booléens serviront de conditions dans les if (chapitre 6) et les boucles (chapitre 7).

Égalité et logique
Figure 1 — == convertit avant de comparer, === non ; opérateurs logiques et valeurs falsy.

Pour afficher plusieurs cas d'un coup, cet exemple utilise une boucle for (chapitre 7) : concentrez-vous sur les résultats affichés.

// 1. Comparer des nombres : le résultat est un booléen
const note = 12;
console.log(note > 10, note >= 12, note < 10, note <= 11, note === 12, note !== 12);

// 2. == convertit les types avant de comparer, === non
const essais = [["5", 5], [0, false], ["", 0], [null, undefined], [null, 0], ["1", true], [NaN, NaN]];
for (const [x, y] of essais) {
  const t = (v) => (typeof v === "string" ? `"${v}"` : String(v));
  console.log(`${t(x).padEnd(9)} vs ${t(y).padEnd(9)}  ==  ${String(x == y).padEnd(5)}  ===  ${x === y}`);
}

// 3. Comparer des chaînes : ordre des codes des caractères
console.log('"b" > "a" :', "b" > "a", '| "B" > "a" :', "B" > "a", '| "10" < "9" :', "10" < "9", '| "10" < 9 :', "10" < 9);

// 4. Objets : on compare des références
console.log("[1] === [1] :", [1] === [1], "| { } === { } :", {} === {});

// 5. Cas particuliers
console.log("NaN === NaN :", NaN === NaN, "| Number.isNaN :", Number.isNaN(NaN), "| Object.is(NaN, NaN) :", Object.is(NaN, NaN));

Résultat dans la console

true true false false true false
"5"       vs 5          ==  true   ===  false
0         vs false      ==  true   ===  false
""        vs 0          ==  true   ===  false
null      vs undefined  ==  true   ===  false
null      vs 0          ==  false  ===  false
"1"       vs true       ==  true   ===  false
NaN       vs NaN        ==  false  ===  false
"b" > "a" : true | "B" > "a" : false | "10" < "9" : true | "10" < 9 : false
[1] === [1] : false | { } === { } : false
NaN === NaN : false | Number.isNaN : true | Object.is(NaN, NaN) : true
  • >, >=, <, <= comparent ; === (strictement égal) et !== (strictement différent) comparent la valeur et le type.
  • == et != convertissent d'abord les deux valeurs selon des règles compliquées : "5" == 5, 0 == false, "" == 0 sont vrais. Utilisez toujours === et !==.
  • Deux chaînes se comparent caractère par caractère selon leur code : "10" < "9" est vrai, et les majuscules passent avant les minuscules. Comparez des nombres avec des nombres.
  • Deux objets ou tableaux ne sont égaux que s'il s'agit du même objet. NaN n'est égal à rien : Number.isNaN.

2. Les opérateurs logiques

// 1. ET (&&), OU (||), NON (!)
const age = 19, inscrit = true, retard = false;
console.log("majeur ET inscrit :", age >= 18 && inscrit);
console.log("retard OU absent :", retard || false);
console.log("NON inscrit :", !inscrit);

// 2. Table de vérité
for (const x of [true, false]) for (const y of [true, false]) {
  console.log(`${String(x).padEnd(5)} ${String(y).padEnd(5)} → && ${String(x && y).padEnd(5)} || ${x || y}`);
}

// 3. Valeurs « falsy » : elles valent false dans une condition
const valeurs = [0, "", null, undefined, NaN, false, "0", " ", [], {}, -1];
const ecrire = (v) => (typeof v === "string" || typeof v === "object" && v !== null ? JSON.stringify(v) : String(v));
console.log(valeurs.map((v) => `${ecrire(v)}→${Boolean(v)}`).join("  "));

// 4. && et || renvoient l'une des deux valeurs (court-circuit)
console.log('"Amina" || "Invité" :', "Amina" || "Invité", '| "" || "Invité" :', "" || "Invité");
console.log('"Amina" && "connectée" :', "Amina" && "connectée", '| null && "x" :', null && "x");

// 5. Priorité : ! puis && puis ||
console.log("true || false && false :", true || false && false, "| (true || false) && false :", (true || false) && false);

// 6. L'opérateur conditionnel (ternaire)
const moyenne = 9.5;
const resultat = moyenne >= 10 ? "admis" : "ajourné";
console.log(`Moyenne ${moyenne} : ${resultat}`);
console.log(`Il reste ${3} place${3 > 1 ? "s" : ""}`);

Résultat dans la console

majeur ET inscrit : true
retard OU absent : false
NON inscrit : false
true  true  → && true  || true
true  false → && false || true
false true  → && false || true
false false → && false || false
0→false  ""→false  null→false  undefined→false  NaN→false  false→false  "0"→true  " "→true  []→true  {}→true  -1→true
"Amina" || "Invité" : Amina | "" || "Invité" : Invité
"Amina" && "connectée" : connectée | null && "x" : null
true || false && false : true | (true || false) && false : false
Moyenne 9.5 : ajourné
Il reste 3 places
  • a && b (ET) est vrai si les deux sont vrais ; a || b (OU) si au moins un est vrai ; !a (NON) inverse. Priorité : !, puis &&, puis ||; des parenthèses rendent l'intention claire.
  • Dans un contexte logique, toute valeur est convertie en booléen. Six valeurs sont falsy: false, 0, "", null, undefined, NaN. Toutes les autres sont truthy, y compris "0", " ", [] et {}.
  • Court-circuit: && et || s'arrêtent dès que le résultat est connu et renvoient l'une des deux valeurs (pas forcément un booléen). D'où l'usage nom || "Invité" pour une valeur par défaut — avec un piège pour 0 et "", que la leçon suivante résout avec ??.
  • Opérateur conditionnel (ternaire) : condition ? valeurSiVrai : valeurSiFaux choisit entre deux valeurs dans une expression.
⚠️ Attention
0 < x < 10 ne teste pas un intervalle : 0 < x donne un booléen, ensuite comparé à 10 (toujours vrai). Écrivez x > 0 && x < 10.
✅ Correction par rapport à l'ancienne version
Nouvelle leçon : tableau ==/=== exécuté sur les cas piégeux, comparaison de chaînes et d'objets, table de vérité, liste complète des valeurs falsy, court-circuit, priorité, opérateur conditionnel et piège de l'intervalle ; schéma et deux activités.
ℹ️ À retenir
• Une comparaison renvoie un booléen ; utilisez === et !==.
• &&: les deux ; ||: au moins un ; !: inverse.
• Falsy : false 0 "" null undefined NaN; tout le reste est truthy.
• c ? a : b choisit une valeur ; un intervalle s'écrit x > 0 && x < 10.

🛠 Activité 13 — Le contrôle d'accès

Mission : Un stagiaire est décrit par age, inscrit (booléen), nbAbsences et moyenne.

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. Écrivez une variable peutPasserExamen vraie si le stagiaire est inscrit ET a moins de 10 absences.
  2. Écrivez mentionTresBien, vraie si la moyenne est entre 16 inclus et 20 inclus. Pourquoi 16 <= moyenne <= 20 est-il faux ?
  3. Écrivez alerte, vraie si le stagiaire a plus de 15 absences OU une moyenne inférieure à 8.
  4. Avec l'opérateur conditionnel, produisez le texte « admis » ou « ajourné » selon la moyenne.
  5. Testez vos variables avec trois stagiaires différents (un cas normal, deux cas limites). Notez les résultats.

Je vérifie / je rends :

  • ☐ Le fichier et le tableau des trois cas testés.

🛠 Activité 14 — == ou === : à vous de juger

Mission : Prévoyez, puis vérifiez.

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. Donnez le résultat de == puis de === pour : "1" et 1; 0 et ""; null et undefined; "abc" et "abc".
  2. Une saisie codeSaisi = "0042" doit être comparée au code 42. Que donne ==? Pourquoi est-ce dangereux pour un code d'accès ?
  3. Lesquelles de ces valeurs sont truthy : "0", 0, "false", [], " ", null, -1? Vérifiez avec Boolean(…).
  4. Que vaut prenom || "Invité" si prenom vaut ""? Et quantite || 1 si la quantité saisie est 0 ? Quel problème voyez-vous ?

Je vérifie / je rends :

  • ☐ Vos prédictions et les résultats réels, avec la réponse à la question 4.

← Les opérateurs en JavaScript (arithmétiques, affectation, incrémentation)Le chaînage optionnel (?.) et l'opérateur de coalescence (??) →

Cet article vous a-t-il aidé ?