Semaine 1 - Jour 3 | Opérateurs et expressions

🔢 Les opérateurs : manipuler les données

Les opérateurs permettent d'effectuer des calculs, des comparaisons et des opérations logiques.

Types d'opérateurs : arithmétiques (+, -, *, /), de comparaison (==, ===, >, <), logiques (&&, ||, !), et bien d'autres.

Important : Utilisez toujours === (égalité stricte) au lieu de == pour éviter les conversions automatiques.

1. Opérateurs arithmétiques

Pour effectuer des calculs mathématiques :

                        // Addition, soustraction, multiplication, division

                        let somme = 10 + 5; // 15

                        let difference = 10 - 5; // 5

                        let produit = 10 * 5; // 50

                        let quotient = 10 / 5; // 2

                        // Modulo (reste de la division)

                        let reste = 10 % 3; // 1

                        // Exponentiation (puissance)

                        let puissance = 2 ** 3; // 8 (2³)

💡 Astuce : Le modulo (%) est très utile pour savoir si un nombre est pair ou impair.

2. Opérateurs de comparaison

Pour comparer des valeurs (retournent true ou false) :

                        // Égalité stricte (type ET valeur)

                        5 === 5; // true

                        5 === '5'; // false (number ≠ string)

                        // Inégalité stricte

                        5 !== 3; // true

                        // Comparaisons

                        10 > 5; // true (supérieur)

                        10 < 5; // false (inférieur)

                        10 >= 10; // true (supérieur ou égal)

                        5 <= 10; // true (inférieur ou égal)

⚠️ Important : Toujours utiliser === et !== (stricte).

3. Opérateurs logiques

Pour combiner des conditions :

                        // ET logique (&&) : les deux conditions doivent être vraies

                        let age = 20;

                        age >= 18 && age < 65; // true

                        // OU logique (||) : au moins une condition vraie

                        age < 18 || age > 65; // false

                        // NON logique (!) : inverse la valeur

                        let estMajeur = true;

                        !estMajeur; // false

✅ Utilisation : Combiner plusieurs conditions dans des tests (if, while...).

4. Template literals

Les template literals (backticks `) permettent d'insérer des variables dans des chaînes.

                        // Ancienne méthode (concaténation)

                        let nom = 'Alice';

                        let age = 25;

                        console.log('Bonjour ' + nom + ', tu as ' + age + ' ans');

                        // Nouvelle méthode (template literals)

                        console.log(`Bonjour ${nom}, tu as ${age} ans`);

                        // Expressions dans les templates

                        console.log(`Dans 5 ans, j'aurai ${age + 5} ans`);

💡 Astuce : Utilisez les backticks (`) pour des chaînes multi-lignes et l'interpolation.

💻 Exemples à tester

                    // Opérateurs arithmétiques

                    let prix = 50;

                    let reduction = 10;

                    let prixFinal = prix - reduction;

                    console.log('Prix final :', prixFinal); // 40

                    // Comparaisons

                    let age = 20;

                    console.log('Majeur ?', age >= 18); // true

                    // Opérateurs logiques

                    let estEtudiant = true;

                    let aReduction = age < 26 && estEtudiant;

                    console.log('Réduction disponible :', aReduction); // true

                    // Template literals

                    let prenom = 'Marie';

                    console.log(`Bonjour ${prenom}, tu as ${age} ans`);

                    console.log(`Prix avec réduction : ${prix - reduction}€`);

👆 Copiez ces exemples dans la console interactive ci-dessus !