Voici la traduction de l'article du russe vers le français, en respectant toutes les règles spécifiées :

Qu'est-ce que c'est et pourquoi ?

Imagine que tu es un robot qui exécute des commandes. Pour prendre des décisions, tu dois être capable de comparer des choses et de vérifier des conditions. Par exemple :

• Comparaison : « As-tu 100 roubles ? » (tu compares ton argent avec le nombre 100).
• Logique : « As-tu 100 roubles ET n'as-tu pas faim ? » (tu vérifies deux conditions à la fois).

En JavaScript, les opérateurs de comparaison et les opérateurs logiques aident l'ordinateur à répondre à ce genre de questions. Le résultat est toujours true (vrai) ou false (faux). C'est comme un feu tricolore : vert – on peut avancer (true), rouge – on s'arrête (false).

Pourquoi en avons-nous besoin ? Sans eux, les programmes seraient ennuyeux – ils exécuteraient simplement les commandes les unes après les autres. Avec eux, le programme peut réagir à différentes situations : par exemple, si l'utilisateur a saisi le bon mot de passe – le laisser entrer, sinon – afficher une erreur.

En Python, ces opérateurs fonctionnent presque de la même manière, mais JavaScript a ses propres particularités. Nous allons les examiner.

Exemples de code avec explications

1. Opérateurs de comparaison de base : >, <, >=, <=

Les plus simples – comme en cours de maths. On compare des nombres :

// Exemple 1 : Plus grand ou plus petit ?
let age = 12;
let peutEntrer = age >= 12; // Peut-on entrer si l'âge est 12 ou plus ?
console.log(peutEntrer); // Affiche : true (car 12 >= 12 — vrai)

// Exemple 2 : Comparaison avec un seuil
let temperature = 30;
let chaud = temperature > 25;   // Plus grand que 25 ?
console.log(chaud); // true (30 > 25 — vrai)

let froid = temperature < 10; // Plus petit que 10 ?
console.log(froid); // false (30 n'est pas plus petit que 10)

// Exemple 3 : On peut aussi comparer des chaînes de caractères !
console.log("pastèque" > "banane"); // false
// Pourquoi ? Les lettres sont comparées par ordre alphabétique : 'p' (16e lettre) est plus grand que 'b' (2e lettre)
// En Python, c'est pareil, mais la sensibilité à la casse est différente

Important : En JavaScript, les chaînes de caractères sont comparées selon le code Unicode (comme dans un tableau). « а » est plus petit que « я », et « А » est plus petit que « а ». C'est comme un dictionnaire : les lettres majuscules viennent en premier, puis les minuscules.

2. Opérateurs d'égalité : == et ===

C'est là que ça devient intéressant ! En JavaScript, il y a deux façons de vérifier si des valeurs sont égales :

• == — « égalité non stricte » (compare les valeurs, mais peut convertir les types)
• === — « égalité stricte » (compare à la fois la valeur et le type de données)

// Exemple 4 : Comparaison de nombres et de chaînes
let nombre = 5;
let chaine = "5";

console.log(nombre == chaine);   // true — car 5 est égal à 5 (JavaScript a converti la chaîne en nombre)
console.log(nombre === chaine);  // false — car un nombre (number) n'est pas égal à une chaîne (string) !

// En Python, cela n'existe pas : "5" == 5 donne False immédiatement, sans conversion

// Exemple 5 : Comparaison avec true/false
console.log(1 == true);  // true — car true est converti en 1
console.log(1 === true); // false — types différents (nombre vs boolean)

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

// Exemple 6 : Valeurs vides
console.log(null == undefined); // true — règle spéciale de JS
console.log(null === undefined); // false — types différents

// En Python, il n'y a pas d'undefined, il y a seulement None, et il n'est égal à rien d'autre qu'à lui-même

Conseil pour les débutants : Utilise toujours === (égalité stricte) pour éviter les surprises. C'est comme en maths : 5 et « 5 » sont des choses différentes, même si elles se ressemblent.

3. Opérateur logique && (ET)

L'opérateur « ET » (AND) retourne true seulement si les deux conditions sont vraies. Dans la vie, c'est comme : « Je vais me promener si j'ai fait mes devoirs ET si maman le permet ».

// Exemple 7 : Vérification de deux conditions
let age = 14;
let aBillet = true;

let peut_aller_au_cinema = (age >= 12) && (aBillet === true);
console.log(peut_aller_au_cinema); // true — l'âge convient ET le billet est présent

// Si l'âge était 10 :
age = 10;
peut_aller_au_cinema = (age >= 12) && (aBillet === true);
console.log(peut_aller_au_cinema); // false — la première condition est fausse, la seconde est vraie, mais ET exige les deux

// Exemple 8 : Condition complexe
let note = 4;
let comportement = "excellent";

let seraFelicite = (note === 5) && (comportement === "excellent");
console.log(seraFelicite); // false — la note n'est pas 5, même si le comportement est excellent

// En Python, cela s'écrit de la même façon : and

Astuce : JavaScript est « paresseux » – si la première condition dans && est fausse, il ne vérifie même pas la seconde. Cela s'appelle « court-circuit ». On économise du temps !

4. Opérateur logique || (OU)

L'opérateur « OU » (OR) retourne true si au moins une condition est vraie. Comme dans la vie : « Je vais me promener si j'ai fait mes devoirs OU s'il fait beau dehors ».

// Exemple 9 : Choix entre deux options
let aArgent = false;
let aCadeau = true;

let peut_acheter_jeu = aArgent || aCadeau;
console.log(peut_acheter_jeu); // true — pas d'argent, mais il y a un cadeau (une condition est vraie)

// Exemple 10 : Vérification de l'âge
let ageUtilisateur = 17;
let entreeAutorisee = (ageUtilisateur >= 18) || (ageUtilisateur >= 16 && aBillet);
// Si l'âge >=18 OU (l'âge >=16 ET a un billet)
console.log(entreeAutorisee); // false — 17 n'est pas >=18, et bien que 17>=16, aBillet n'est pas défini (undefined — c'est false)

// Exemple 11 : Valeurs par défaut
let nom = "";
let nomAffiche = nom || "Invité";
console.log(nomAffiche); // "Invité" — car une chaîne vide est considérée comme false

// En Python : nom or "Invité" — fonctionne de la même manière

Astuce : || est aussi « paresseux » – si la première condition est vraie, la seconde n'est pas vérifiée. On utilise cela pour définir des valeurs par défaut.

5.