Booléens et comparaisons

5 == "5" vaut true mais 5 === "5" vaut false. Le triple signe égal vérifie aussi que les deux côtés sont du même type.

Des questions à réponse oui ou non

Les programmes posent sans cesse des questions. Le mot de passe est-il assez long ? Le joueur n'a-t-il plus de vies ? Est-ce le week-end aujourd'hui ? Chacune a l'une de deux réponses, et JavaScript les représente avec les deux valeurs booléennes, true (vrai) et false (faux). Les booléens doivent leur nom à George Boole, le mathématicien du dix-neuvième siècle qui a mis au point une algèbre du vrai et du faux. Seuls, ils ne sont pas très passionnants, mais ce sont eux qui permettent à un programme de prendre des décisions, le sujet de l'unité suivante.

Les opérateurs de comparaison

Une comparaison prend deux valeurs et produit un booléen. Voici les six que tu utiliseras le plus. Remarque que « égal » s'écrit avec trois signes égal, car un seul = signifie déjà « ranger une valeur ».

Comme un calcul, une comparaison est une expression : tu peux l'afficher ou la ranger dans une variable. const isAdult = age >= 18; range true ou false dans isAdult selon l'âge. Les noms de variables booléennes commencent souvent par is, has ou can, ce qui fait lire le code comme une question.

Pourquoi === et pas ==

JavaScript a aussi un double égal, ==, appelé égalité large. Avant de comparer, il essaie de convertir les deux côtés dans le même type, ce qui donne des résultats difficiles à prévoir : 5 == "5" vaut true, et 0 == "" aussi. Le triple égal ===, l'égalité stricte, ne convertit jamais. Si les types diffèrent, la réponse est tout simplement false. MDN et la plupart des guides de style recommandent === et !== pour le code de tous les jours, et ce cours les utilise partout.

console.log(5 === 5);      // true
console.log(5 === "5");    // false (types différents)
// égalité large, à éviter :
console.log(5 == "5");     // true
console.log("cat" !== "dog"); // true

On peut aussi comparer des chaînes. === vérifie que deux chaînes ont exactement les mêmes caractères, majuscules comprises : "Yes" === "yes" vaut donc false. Les opérateurs < et > comparent les chaînes caractère par caractère d'après leurs codes, ce qui est proche de l'ordre du dictionnaire pour les mots en minuscules : "apple" < "banana" vaut true. Dans cet ordre, les majuscules viennent avant toutes les minuscules : "Zebra" < "apple" vaut donc aussi true.

Combiner des réponses avec &&, || et !

Les vraies questions ont souvent plusieurs parties. Un manège peut exiger une taille d'au moins 120 cm et un âge d'au moins 8 ans. JavaScript relie les réponses booléennes avec des opérateurs logiques. && (et) vaut true seulement quand les deux côtés valent true. || (ou) vaut true quand au moins un côté vaut true. ! (non) inverse un booléen : !true vaut false.

const height = 130;
const age = 7;
console.log(height >= 120 && age >= 8);   // false (il faut les deux)
console.log(height >= 120 || age >= 8);   // true (un seul suffit)
console.log(!(age >= 8));                 // true

Exemple corrigé. Un jour est-il un jour de week-end ? day === "Sat" || day === "Sun". Remarque qu'il faut répéter day === des deux côtés. Écrire day === "Sat" || "Sun" paraît naturel en anglais mais ne fait pas ce que tu veux, car "Sun" tout seul n'est pas une comparaison. Les comparaisons sont calculées avant && et || : height >= 120 && age >= 8 n'a donc pas besoin de parenthèses en plus, même si en ajouter ne fait jamais de mal.

Encore une idée que tu retrouveras plus tard : quand JavaScript a besoin d'un booléen mais reçoit une autre valeur, il considère quelques valeurs comme fausses. Ces valeurs falsy sont false, 0, la chaîne vide "", null, undefined et NaN. Tout le reste, y compris les chaînes "0" et "false", compte comme vrai.