Bye Bye Prof

Cours2

Cours JavaScript pour Débutants - Guide Complet

Table des Matières

  1. Introduction au JavaScript
  2. Les Types de Données Primitifs
  3. Les Variables
  4. Les Chaînes de Caractères
  5. Les Opérateurs de Comparaison
  6. Les Structures Conditionnelles
  7. Les Tableaux
  8. Les Objets
  9. Les Boucles
  10. Les Fonctions
  11. Le DOM (Document Object Model)
  12. Les Événements

Introduction au JavaScript

Qu'est-ce que JavaScript ?

JavaScript est un langage de programmation dynamique conçu pour rendre les pages web interactives. Contrairement à HTML qui définit la structure d'une page et CSS qui gère son apparence, JavaScript apporte la fonctionnalité et l'interactivité.

Un peu d'histoire

L'histoire de JavaScript remonte aux années 1990, lorsque le World Wide Web commençait à prendre de l'ampleur. À cette époque, les pages web étaient principalement statiques, et il n'était pas possible d'ajouter des fonctionnalités interactives.

Pour répondre à ce besoin, Netscape Communications Corporation a créé un langage de programmation appelé LiveScript en septembre 1995. LiveScript a ensuite été renommé JavaScript en décembre 1995, dans le but de capitaliser sur la popularité croissante de Java à cette époque.

Important : JavaScript et Java sont deux langages complètement différents malgré la similarité de leurs noms !

Aujourd'hui, JavaScript est devenu l'un des langages de programmation les plus populaires au monde et est utilisé pour :

Les trois piliers du développement web

HTML  → Structure (le squelette)
CSS   → Présentation (l'apparence)
JS    → Comportement (l'interactivité)

Exemple concret :


Les Types de Données Primitifs

Définition des types primitifs

En JavaScript, les types primitifs sont les types de données de base qui ne sont pas des objets et n'ont pas de méthodes. Ils représentent des valeurs simples et immuables (qui ne peuvent pas être modifiées directement).

Les 6 types primitifs

1. Number (Nombre)

Représente tous les nombres, qu'ils soient entiers ou décimaux.

let age = 25;              // Entier
let prix = 19.99;          // Décimal
let temperature = -5;       // Nombre négatif
let infini = Infinity;     // Valeur infinie
let pasUnNombre = NaN;     // "Not a Number"

Cas particulier : NaN (Not a Number)

NaN apparaît lorsqu'une opération mathématique échoue :

console.log(10 / "abc");     // NaN
console.log(Math.sqrt(-1));  // NaN
console.log(0 / 0);          // NaN

// Pour vérifier si une valeur est NaN :
console.log(isNaN(NaN));           // true
console.log(Number.isNaN(NaN));    // true (plus strict)

2. String (Chaîne de caractères)

Représente du texte, délimité par des guillemets simples, doubles ou des backticks.

let prenom = "Marie";
let nom = 'Dupont';
let phrase = `Bonjour ${prenom} ${nom}!`;  // Template literal

3. Boolean (Booléen)

Représente une valeur logique : soit true (vrai) soit false (faux).

let estMajeur = true;
let estMineur = false;
let resultat = 5 > 3;  // true

4. Undefined

Valeur automatiquement assignée aux variables déclarées mais non initialisées.

let variable;
console.log(variable);  // undefined

function test() {}
console.log(test());    // undefined (fonction sans return)

5. Null

Représente l'absence intentionnelle de valeur.

let donnees = null;  // Indique explicitement qu'il n'y a pas de données

6. Symbol

Type introduit en ES6, utilisé pour créer des identifiants uniques.

let id = Symbol('identifiant');
let autreId = Symbol('identifiant');
console.log(id === autreId);  // false (chaque Symbol est unique)

Vérification des types

Utilisez l'opérateur typeof pour connaître le type d'une variable :

console.log(typeof 42);        // "number"
console.log(typeof "Bonjour"); // "string"
console.log(typeof true);      // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null);      // "object" (particularité historique de JS)

Les Variables

Qu'est-ce qu'une variable ?

Une variable est un conteneur nommé qui stocke une valeur. Pensez à une variable comme à une boîte étiquetée dans laquelle vous pouvez placer différents objets.

Les trois façons de déclarer une variable

1. var (à éviter - obsolète)

var ancienneMethode = "Ne plus utiliser";

2. let (recommandée pour les valeurs qui changent)

let compteur = 0;
compteur = 1;        // ✅ Possible de modifier
compteur = compteur + 1;  // ✅ Modification autorisée

3. const (recommandée pour les valeurs constantes)

const PI = 3.14159;
const COULEUR_ROUGE = "#FF0000";
// PI = 3.14;  ❌ Erreur ! Impossible de modifier une constante

Règles de nommage des variables

Conventions obligatoires :

Bonnes pratiques :

// ✅ Bons exemples
let ageUtilisateur = 25;
let estConnecte = false;
const NOMBRE_MAX_TENTATIVES = 3;
let listeProduits = [];

// ❌ Mauvais exemples
let a = 25;           // Pas descriptif
let user-age = 25;    // Caractère interdit
let 2name = "Marie";  // Commence par un chiffre

Portée (Scope) des variables

La portée détermine où une variable peut être utilisée dans le code.

Portée globale

let variableGlobale = "Accessible partout";

function test() {
    console.log(variableGlobale);  // ✅ Accessible
}

Portée de bloc

function exemple() {
    if (true) {
        let variableLocale = "Seulement ici";
        console.log(variableLocale);  // ✅ Accessible
    }
    // console.log(variableLocale);  ❌ Erreur ! Hors de portée
}

Les Chaînes de Caractères

Création de chaînes

JavaScript offre trois façons de créer des chaînes de caractères :

let simple = 'Guillemets simples';
let double = "Guillemets doubles";
let template = `Template literals`;

Échappement de caractères

Pour inclure des caractères spéciaux, utilisez le caractère d'échappement \ :

let citation = "Il a dit : \"Bonjour !\"";
let nouvelleLigne = "Première ligne\nDeuxième ligne";
let tabulation = "Colonne1\tColonne2";
let antislash = "Chemin : C:\\dossier\\fichier.txt";

Template Literals (Littéraux de gabarits)

Les template literals utilisent des backticks ` et permettent :

Interpolation de variables

let prenom = "Alice";
let age = 30;
let message = `Bonjour ${prenom}, vous avez ${age} ans.`;
console.log(message);  // "Bonjour Alice, vous avez 30 ans."

Chaînes multi-lignes

let poeme = `
    Les roses sont rouges,
    Les violettes sont bleues,
    JavaScript est génial,
    Et ce cours aussi !
`;

Expressions dans les template literals

let a = 10;
let b = 5;
let resultat = `${a} + ${b} = ${a + b}`;  // "10 + 5 = 15"

Méthodes importantes des chaînes

Propriétés

let texte = "Bonjour le monde";
console.log(texte.length);  // 16 (nombre de caractères)

Méthodes de transformation

let phrase = "  Bonjour Le Monde  ";

// Casse
console.log(phrase.toLowerCase());     // "  bonjour le monde  "
console.log(phrase.toUpperCase());     // "  BONJOUR LE MONDE  "

// Espaces
console.log(phrase.trim());            // "Bonjour Le Monde"

// Remplacement
console.log(phrase.replace("Bonjour", "Salut"));  // "  Salut Le Monde  "

Méthodes de découpage

let email = "user@example.com";

// Extraction
console.log(email.substring(0, 4));    // "user"
console.log(email.slice(-3));          // "com"

// Division
console.log(email.split("@"));         // ["user", "example.com"]

Méthodes de recherche

let phrase = "JavaScript est formidable";

// Position
console.log(phrase.indexOf("Script"));       // 4
console.log(phrase.lastIndexOf("a"));        // 22

// Vérification
console.log(phrase.includes("Java"));        // true
console.log(phrase.startsWith("Java"));      // true
console.log(phrase.endsWith("ble"));         // true

Concaténation de chaînes

// Méthode classique
let nom = "Alice";
let salutation = "Bonjour " + nom + " !";

// Méthode moderne (template literals)
let salutationModerne = `Bonjour ${nom} !`;

// Méthode concat()
let resultat = "Bonjour ".concat(nom, " !");

Les Opérateurs de Comparaison

Types d'opérateurs de comparaison

Les opérateurs de comparaison permettent de comparer deux valeurs et retournent toujours un booléen (true ou false).

Égalité et inégalité

// Égalité simple (== - conversion automatique)
console.log(5 == "5");     // true (conversion de type)
console.log(true == 1);    // true
console.log(false == 0);   // true

// Égalité stricte (=== - recommandée)
console.log(5 === "5");    // false (types différents)
console.log(5 === 5);      // true

// Inégalité simple (!=)
console.log(5 != "6");     // true

// Inégalité stricte (!==)
console.log(5 !== "5");    // true (types différents)

Comparaisons numériques

let a = 10;
let b = 5;

console.log(a > b);   // true  (10 est supérieur à 5)
console.log(a < b);   // false (10 n'est pas inférieur à 5)
console.log(a >= 10); // true  (10 est égal à 10)
console.log(b <= 4);  // false (5 n'est pas inférieur ou égal à 4)

Comparaisons de chaînes

Les chaînes sont comparées selon l'ordre lexicographique (ordre alphabétique Unicode) :

console.log("apple" < "banana");    // true
console.log("Zoo" < "apple");       // true (majuscules avant minuscules)
console.log("10" < "2");            // true (comparaison alphabétique)
console.log("10" < "9");            // true

Truthiness vs Falsiness

JavaScript convertit automatiquement les valeurs en booléens dans certains contextes.

Valeurs falsy (considérées comme fausses)

if (false) { /* ne s'exécute pas */ }
if (0) { /* ne s'exécute pas */ }
if (-0) { /* ne s'exécute pas */ }
if (0n) { /* ne s'exécute pas */ }  // BigInt zéro
if ("") { /* ne s'exécute pas */ }  // Chaîne vide
if (null) { /* ne s'exécute pas */ }
if (undefined) { /* ne s'exécute pas */ }
if (NaN) { /* ne s'exécute pas */ }

Valeurs truthy (considérées comme vraies)

if (true) { /* s'exécute */ }
if (1) { /* s'exécute */ }
if (-1) { /* s'exécute */ }
if ("hello") { /* s'exécute */ }
if ("0") { /* s'exécute - chaîne non vide */ }
if ([]{ /* s'exécute - tableau vide mais c'est un objet */ }
if ({}) { /* s'exécute - objet vide */ }

Exemple pratique

let utilisateur = "";

if (utilisateur) {
    console.log(`Bienvenue ${utilisateur}`);
} else {
    console.log("Veuillez vous connecter");  // S'exécute car "" est falsy
}

Opérateurs logiques

L'opérateur ET (&&)

Retourne true seulement si toutes les conditions sont vraies.

let age = 25;
let aPermis = true;

if (age >= 18 && aPermis) {
    console.log("Peut conduire");  // S'exécute
}

// Court-circuit : si la première condition est fausse, 
// la seconde n'est pas évaluée
let resultat = false && console.log("Ne s'affiche pas");

L'opérateur OU (||)

Retourne true si au moins une condition est vraie.

let estWeekend = true;
let estVacances = false;

if (estWeekend || estVacances) {
    console.log("Pas de travail !");  // S'exécute
}

// Utilisation pour valeur par défaut
let nom = "" || "Utilisateur anonyme";  // "Utilisateur anonyme"

L'opérateur NON (!)

Inverse la valeur booléenne.

let estConnecte = false;

if (!estConnecte) {
    console.log("Veuillez vous connecter");  // S'exécute
}

// Double négation pour convertir en booléen
console.log(!!0);        // false
console.log(!!"hello");  // true

L'objet Console

L'objet console fournit des méthodes pour afficher des informations dans la console du navigateur :

// Messages simples
console.log("Message d'information");
console.info("Information importante");
console.warn("Avertissement");
console.error("Erreur détectée");

// Affichage de tableaux
let fruits = ["pomme", "banane", "orange"];
console.table(fruits);

// Groupement de messages
console.group("Détails utilisateur");
console.log("Nom: Alice");
console.log("Age: 30");
console.groupEnd();

// Nettoyage de la console
console.clear();

Les Structures Conditionnelles

L'instruction if

La structure conditionnelle if permet d'exécuter du code seulement si une condition est vraie.

Syntaxe de base

if (condition) {
    // Code exécuté si la condition est vraie
}

Exemple pratique

let temperature = 25;

if (temperature > 20) {
    console.log("Il fait beau !");
}

L'instruction if...else

Permet d'exécuter du code différent selon que la condition soit vraie ou fausse.

let age = 17;

if (age >= 18) {
    console.log("Vous êtes majeur");
} else {
    console.log("Vous êtes mineur");
}

L'instruction if...else if...else

Pour tester plusieurs conditions successives :

let note = 85;

if (note >= 90) {
    console.log("Excellent !");
} else if (note >= 80) {
    console.log("Très bien !");
} else if (note >= 70) {
    console.log("Bien !");
} else if (note >= 60) {
    console.log("Passable");
} else {
    console.log("Insuffisant");
}

L'instruction switch

Utile quand vous devez comparer une valeur à plusieurs options :

let jour = "lundi";

switch (jour) {
    case "lundi":
        console.log("Début de semaine");
        break;
    case "mardi":
    case "mercredi":
    case "jeudi":
        console.log("Milieu de semaine");
        break;
    case "vendredi":
        console.log("Bientôt le weekend !");
        break;
    case "samedi":
    case "dimanche":
        console.log("Weekend !");
        break;
    default:
        console.log("Jour invalide");
}

Important : Le mot-clé break est essentiel pour éviter l'exécution des cas suivants.

Opérateur ternaire

Une façon concise d'écrire une condition simple :

// Syntaxe : condition ? valeurSiVrai : valeurSiFaux
let age = 20;
let statut = age >= 18 ? "majeur" : "mineur";
console.log(statut);  // "majeur"

// Équivalent avec if...else
let statutLong;
if (age >= 18) {
    statutLong = "majeur";
} else {
    statutLong = "mineur";
}

Conditions complexes

Validation de formulaire

function validerUtilisateur(nom, email, age) {
    if (!nom || nom.trim() === "") {
        return "Le nom est obligatoire";
    }
    
    if (!email || !email.includes("@")) {
        return "Email invalide";
    }
    
    if (age < 0 || age > 120) {
        return "Age invalide";
    }
    
    return "Utilisateur valide";
}

console.log(validerUtilisateur("Alice", "alice@test.com", 25));

Conditions avec opérateurs logiques

let utilisateur = {
    nom: "Alice",
    age: 25,
    estPremium: true,
    credits: 50
};

// Accès autorisé si premium OU (majeur ET a des crédits)
if (utilisateur.estPremium || (utilisateur.age >= 18 && utilisateur.credits > 0)) {
    console.log("Accès autorisé");
} else {
    console.log("Accès refusé");
}

Les Tableaux

Qu'est-ce qu'un tableau ?

Un tableau (array) est une structure de données qui permet de stocker plusieurs valeurs dans une seule variable. Ces valeurs sont ordonnées et indexées à partir de 0.

// Analogie : un tableau c'est comme un casier avec des compartiments numérotés
//    [0]      [1]       [2]       [3]
let fruits = ["pomme", "banane", "orange", "kiwi"];

Création de tableaux

Plusieurs façons de créer un tableau

// Littéral de tableau (recommandé)
let vide = [];
let nombres = [1, 2, 3, 4, 5];
let mixte = ["Alice", 25, true, null];

// Constructeur Array
let autreTableau = new Array(5);        // Tableau de 5 éléments vides
let encoreUnAutre = new Array(1, 2, 3); // [1, 2, 3]

Accès aux éléments

let fruits = ["pomme", "banane", "orange"];

// Lecture
console.log(fruits[0]);  // "pomme"
console.log(fruits[1]);  // "banane"
console.log(fruits[2]);  // "orange"
console.log(fruits[3]);  // undefined (n'existe pas)

// Modification
fruits[1] = "mangue";
console.log(fruits);     // ["pomme", "mangue", "orange"]

// Ajout d'un élément à une position spécifique
fruits[3] = "ananas";
console.log(fruits);     // ["pomme", "mangue", "orange", "ananas"]

Propriétés importantes

La propriété length

let nombres = [10, 20, 30, 40, 50];
console.log(nombres.length);  // 5

// Modifier la taille du tableau
nombres.length = 3;
console.log(nombres);         // [10, 20, 30]

nombres.length = 5;
console.log(nombres);         // [10, 20, 30, undefined, undefined]

Méthodes de modification

Ajout d'éléments

let fruits = ["pomme", "banane"];

// push() - Ajoute à la fin
fruits.push("orange");
console.log(fruits);  // ["pomme", "banane", "orange"]

// Ajouter plusieurs éléments
fruits.push("kiwi", "mangue");
console.log(fruits);  // ["pomme", "banane", "orange", "kiwi", "mangue"]

// unshift() - Ajoute au début
fruits.unshift("fraise");
console.log(fruits);  // ["fraise", "pomme", "banane", "orange", "kiwi", "mangue"]

Suppression d'éléments

let fruits = ["fraise", "pomme", "banane", "orange"];

// pop() - Supprime le dernier élément
let dernierFruit = fruits.pop();
console.log(dernierFruit);  // "orange"
console.log(fruits);        // ["fraise", "pomme", "banane"]

// shift() - Supprime le premier élément
let premierFruit = fruits.shift();
console.log(premierFruit);  // "fraise"
console.log(fruits);        // ["pomme", "banane"]

Méthode splice() - Couteau suisse des tableaux

let nombres = [1, 2, 3, 4, 5];

// Syntaxe : array.splice(index, nombreÀSupprimer, ...élémentsÀAjouter)

// Supprimer 2 éléments à partir de l'index 1
let supprimes = nombres.splice(1, 2);
console.log(supprimes);  // [2, 3]
console.log(nombres);    // [1, 4, 5]

// Ajouter des éléments sans rien supprimer
nombres.splice(1, 0, "a", "b");
console.log(nombres);    // [1, "a", "b", 4, 5]

// Remplacer des éléments
nombres.splice(1, 2, 2, 3);
console.log(nombres);    // [1, 2, 3, 4, 5]

Méthodes de recherche

Recherche d'éléments

let fruits = ["pomme", "banane", "orange", "pomme"];

// indexOf() - Première occurrence
console.log(fruits.indexOf("pomme"));     // 0
console.log(fruits.indexOf("kiwi"));      // -1 (non trouvé)

// lastIndexOf() - Dernière occurrence
console.log(fruits.lastIndexOf("pomme")); // 3

// includes() - Vérifier la présence
console.log(fruits.includes("banane"));   // true
console.log(fruits.includes("kiwi"));     // false

Recherche avec condition (méthodes avancées)

let personnes = [
    { nom: "Alice", age: 25 },
    { nom: "Bob", age: 30 },
    { nom: "Charlie", age: 35 }
];

// find() - Premier élément qui satisfait la condition
let personne30 = personnes.find(p => p.age === 30);
console.log(personne30);  // { nom: "Bob", age: 30 }

// findIndex() - Index du premier élément trouvé
let index = personnes.findIndex(p => p.nom === "Charlie");
console.log(index);  // 2

Méthodes de manipulation

Copie et extraction

let nombres = [1, 2, 3, 4, 5];

// slice() - Copie une portion (ne modifie pas l'original)
let portion = nombres.slice(1, 4);  // De l'index 1 à 3 (4 exclu)
console.log(portion);  // [2, 3, 4]
console.log(nombres);  // [1, 2, 3, 4, 5] (inchangé)

// Copie complète
let copie = nombres.slice();

Concaténation

let groupe1 = ["Alice", "Bob"];
let groupe2 = ["Charlie", "David"];

// concat() - Combine des tableaux
let tousLesNoms = groupe1.concat(groupe2);
console.log(tousLesNoms);  // ["Alice", "Bob", "Charlie", "David"]

// Spread operator (syntaxe moderne)
let autreCombinaison = [...groupe1, ...groupe2, "Eve"];
console.log(autreCombinaison);  // ["Alice", "Bob", "Charlie", "David", "Eve"]

Transformation

let mots = ["bonjour", "le", "monde"];

// join() - Convertit en chaîne
console.log(mots.join(" "));     // "bonjour le monde"
console.log(mots.join("-"));     // "bonjour-le-monde"

// reverse() - Inverse l'ordre (modifie l'original)
let nombres = [1, 2, 3, 4, 5];
nombres.reverse();
console.log(nombres);  // [5, 4, 3, 2, 1]

// sort() - Tri (modifie l'original)
let fruits = ["orange", "pomme", "banane"];
fruits.sort();
console.log(fruits);  // ["banane", "orange", "pomme"]

// Tri numérique (important!)
let nombres2 = [10, 2, 30, 4];
nombres2.sort((a, b) => a - b);  // Tri croissant
console.log(nombres2);  // [2, 4, 10, 30]

Tableaux multidimensionnels

Un tableau peut contenir d'autres tableaux, créant ainsi une structure matricielle :

// Matrice 3x3
let matrice = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];

// Accès aux éléments
console.log(matrice[0][0]);  // 1
console.log(matrice[1][2]);  // 6
console.log(matrice[2][1]);  // 8

// Modification
matrice[1][1] = 99;
console.log(matrice[1]);     // [4, 99, 6]

Exemple pratique : Jeu de Tic-Tac-Toe

let plateau = [
    ["X", "O", "X"],
    ["O", "X", "O"],
    ["X", "X", "O"]
];

function afficherPlateau(plateau) {
    for (let i = 0; i < plateau.length; i++) {
        console.log(plateau[i].join(" | "));
        if (i < plateau.length - 1) {
            console.log("---------");
        }
    }
}

afficherPlateau(plateau);
// X | O | X
// ---------
// O | X | O
// ---------
// X | X | O

Particularité : const avec les tableaux

const fruits = ["pomme", "banane"];

// ✅ Modification du contenu autorisée
fruits.push("orange");
fruits[0] = "fraise";
console.log(fruits);  // ["fraise", "banane", "orange"]

// ❌ Réassignation interdite
// fruits = ["nouvelle", "liste"];  // Erreur !

Méthodes d'itération modernes

forEach() - Exécuter une fonction pour chaque élément

let nombres = [1, 2, 3, 4, 5];

nombres.forEach(function(nombre, index) {
    console.log(`Index ${index}: ${nombre}`);
});

// Version avec arrow function
nombres.forEach((nombre, index) => {
    console.log(`Index ${index}: ${nombre * 2}`);
});

map() - Créer un nouveau tableau transformé

let nombres = [1, 2, 3, 4, 5];
let doubles = nombres.map(n => n * 2);
console.log(doubles);  // [2, 4, 6, 8, 10]

let personnes = ["alice", "bob", "charlie"];
let personnesTout = personnes.map(nom => nom.toUpperCase());
console.log(personnesTout);  // ["ALICE", "BOB", "CHARLIE"]

filter() - Filtrer les éléments

let nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let pairs = nombres.filter(n => n % 2 === 0);
console.log(pairs);  // [2, 4, 6, 8, 10]

let mots = ["chat", "chien", "oiseau", "poisson"];
let motsLongs = mots.filter(mot => mot.length > 4);
console.log(motsLongs);  // ["chien", "oiseau", "poisson"]

Les Objets

Qu'est-ce qu'un objet ?

Un objet est une structure de données qui permet de regrouper des propriétés (caractéristiques) et des méthodes (comportements) dans une seule entité. Contrairement aux tableaux qui stockent des valeurs ordonnées, les objets stockent des paires clé-valeur.

// Analogie : Un objet c'est comme une fiche d'identité
let personne = {
    nom: "Alice",           // propriété
    age: 30,               // propriété
    ville: "Paris",        // propriété
    sePresenter: function() {  // méthode
        return `Je suis ${this.nom}`;
    }
};

Création d'objets

Littéral d'objet (Object Literal)

let voiture = {
    marque: "Toyota",
    modele: "Corolla",
    annee: 2023,
    couleur: "rouge",
    estDemarree: false
};

Objet vide

let objetVide = {};
let autreObjet = new Object();  // Équivalent mais moins utilisé

Accès aux propriétés

Notation par points (dot notation)

let personne = {
    nom: "Bob",
    age: 25,
    adresse: {
        rue: "123 rue de la Paix",
        ville: "Lyon"
    }
};

console.log(personne.nom);              // "Bob"
console.log(personne.age);              // 25
console.log(personne.adresse.ville);    // "Lyon"

Notation par crochets (bracket notation)

let personne = {
    nom: "Charlie",
    age: 35,
    "code postal": "75001"  // Propriété avec espace
};

console.log(personne["nom"]);           // "Charlie"
console.log(personne["code postal"]);   // "75001"

// Utile avec des variables
let propriete = "age";
console.log(personne[propriete]);       // 35

Modification d'objets

Ajout et modification de propriétés

let animal = {
    type: "chat",
    nom: "Whiskers"
};

// Modification
animal.nom = "Fluffy";
animal["type"] = "chien";

// Ajout
animal.age = 3;
animal["couleur"] = "blanc";

console.log(animal);
// { type: "chien", nom: "Fluffy", age: 3, couleur: "blanc" }

Suppression de propriétés

let produit = {
    nom: "Laptop",
    prix: 999,
    stock: 0,
    enPromotion: false
};

delete produit.stock;
delete produit["enPromotion"];

console.log(produit);  // { nom: "Laptop", prix: 999 }

Méthodes d'objets

Définir des méthodes

let calculatrice = {
    resultat: 0,
    
    ajouter: function(nombre) {
        this.resultat += nombre;
        return this;  // Permet le chainage
    },
    
    multiplier: function(nombre) {
        this.resultat *= nombre;
        return this;
    },
    
    afficher: function() {
        console.log(`Résultat: ${this.resultat}`);
        return this;
    },
    
    reset: function() {
        this.resultat = 0;
        return this;
    }
};

// Utilisation
calculatrice.ajouter(5).multiplier(2).afficher();  // Résultat: 10

Syntaxe moderne (ES6+)

let personne = {
    nom: "David",
    age: 28,
    
    // Méthode raccourcie
    sePresenter() {
        return `Bonjour, je suis ${this.nom} et j'ai ${this.age} ans`;
    },
    
    vieillir() {
        this.age++;
        console.log(`${this.nom} a maintenant ${this.age} ans`);
    }
};

Objets complexes

Objets imbriqués

let entreprise = {
    nom: "TechCorp",
    fondation: 2010,
    adresse: {
        rue: "456 Avenue de l'Innovation",
        ville: "Paris",
        codePostal: "75001",
        coordonnees: {
            latitude: 48.8566,
            longitude: 2.3522
        }
    },
    employes: [
        { nom: "Alice", poste: "Développeuse" },
        { nom: "Bob", poste: "Designer" },
        { nom: "Charlie", poste: "Manager" }
    ],
    
    ajouterEmploye(nom, poste) {
        this.employes.push({ nom, poste });
    },
    
    obtenirAdresseComplete() {
        const addr = this.adresse;
        return `${addr.rue}, ${addr.codePostal} ${addr.ville}`;
    }
};

console.log(entreprise.obtenirAdresseComplete());
entreprise.ajouterEmploye("Diana", "Analyste");

Comparaison Objets vs Tableaux

Aspect Tableaux Objets
Structure Liste ordonnée Paires clé-valeur
Index Numérique (0, 1, 2...) Chaînes de caractères
Ordre Important Non garanti
Utilisation Collections d'éléments similaires Entités avec propriétés
// Tableau : Liste de produits
let produits = ["Laptop", "Souris", "Clavier", "Écran"];

// Objet : Un produit spécifique
let produit = {
    nom: "Laptop",
    prix: 999,
    marque: "Dell",
    enStock: true
};

// Combinaison : Tableau d'objets
let inventaire = [
    { nom: "Laptop", prix: 999, stock: 5 },
    { nom: "Souris", prix: 25, stock: 20 },
    { nom: "Clavier", prix: 75, stock: 15 }
];

Méthodes utiles pour les objets

Object.keys(), Object.values(), Object.entries()

let personne = {
    nom: "Emma",
    age: 32,
    profession: "Médecin"
};

// Obtenir les clés
console.log(Object.keys(personne));     // ["nom", "age", "profession"]

// Obtenir les valeurs
console.log(Object.values(personne));   // ["Emma", 32, "Médecin"]

// Obtenir les paires clé-valeur
console.log(Object.entries(personne));  // [["nom", "Emma"], ["age", 32], ["profession", "Médecin"]]

Vérification de propriétés

let livre = {
    titre: "JavaScript Guide",
    auteur: "John Doe",
    pages: 350
};

// Vérifier si une propriété existe
console.log("titre" in livre);                    // true
console.log(livre.hasOwnProperty("auteur"));      // true
console.log(livre.hasOwnProperty("editeur"));     // false

// Vérification sûre
if (livre.editeur) {
    console.log(livre.editeur);
} else {
    console.log("Éditeur non spécifié");
}

Les Boucles

Qu'est-ce qu'une boucle ?

Une boucle est une structure de contrôle qui permet d'exécuter répétitivement un bloc de code tant qu'une condition est satisfaite. Les boucles évitent la répétition de code et permettent de traiter des collections de données efficacement.

La boucle for

Syntaxe et fonctionnement

// Syntaxe : for (initialisation; condition; itération)
for (let i = 0; i < 5; i++) {
    console.log(`Itération ${i}`);
}

// Sortie :
// Itération 0
// Itération 1
// Itération 2
// Itération 3
// Itération 4

Décomposition de la boucle for

  1. Initialisation (let i = 0) : Exécutée une seule fois au début
  2. Condition (i < 5) : Vérifiée avant chaque itération
  3. Bloc de code : Exécuté si la condition est vraie
  4. Itération (i++) : Exécutée après chaque passage dans le bloc

Exemples pratiques

// Parcourir un tableau
let fruits = ["pomme", "banane", "orange", "kiwi"];

for (let i = 0; i < fruits.length; i++) {
    console.log(`${i}: ${fruits[i]}`);
}

// Boucle décroissante
for (let i = 10; i >= 1; i--) {
    console.log(`Décompte: ${i}`);
}
console.log("Décollage !");

// Boucle avec pas personnalisé
for (let i = 0; i <= 20; i += 2) {
    console.log(`Nombre pair: ${i}`);
}

La boucle while

Exécute un bloc tant qu'une condition reste vraie.

let compteur = 0;

while (compteur < 3) {
    console.log(`Compteur: ${compteur}`);
    compteur++;  // Important : modifier la variable de condition !
}

// Exemple pratique : Deviner un nombre
let nombreSecret = 7;
let tentative = 0;

while (tentative !== nombreSecret) {
    tentative = Math.floor(Math.random() * 10) + 1;
    console.log(`Tentative: ${tentative}`);
}
console.log("Trouvé !");

Attention : Assurez-vous que la condition finira par devenir fausse pour éviter une boucle infinie !

La boucle do...while

Similaire à while, mais garantit que le bloc s'exécute au moins une fois.

let reponse;

do {
    reponse = prompt("Voulez-vous continuer ? (oui/non)");
    console.log(`Vous avez répondu: ${reponse}`);
} while (reponse !== "non");

console.log("Au revoir !");

La boucle for...in

Parcourt les propriétés énumérables d'un objet.

let personne = {
    nom: "Alice",
    age: 30,
    profession: "Développeuse",
    ville: "Paris"
};

for (let propriete in personne) {
    console.log(`${propriete}: ${personne[propriete]}`);
}

// Sortie :
// nom: Alice
// age: 30
// profession: Développeuse
// ville: Paris

Utilisation avec les tableaux (déconseillée)

let couleurs = ["rouge", "vert", "bleu"];

// ❌ Déconseillé avec les tableaux
for (let index in couleurs) {
    console.log(couleurs[index]);  // index est une chaîne !
}

// ✅ Préférer for...of pour les tableaux

La boucle for...of

Parcourt les valeurs d'un objet itérable (tableaux, chaînes, etc.).

let fruits = ["pomme", "banane", "orange"];

// Parcours simple
for (let fruit of fruits) {
    console.log(fruit);
}

// Avec l'index (en utilisant entries())
for (let [index, fruit] of fruits.entries()) {
    console.log(`${index}: ${fruit}`);
}

// Parcours d'une chaîne
let mot = "Bonjour";
for (let lettre of mot) {
    console.log(lettre);
}
// B o n j o u r

Contrôle du flux des boucles

L'instruction break

Interrompt complètement la boucle.

// Chercher un élément spécifique
let nombres = [1, 3, 7, 12, 8, 15];
let cible = 12;
let trouve = false;

for (let i = 0; i < nombres.length; i++) {
    if (nombres[i] === cible) {
        console.log(`${cible} trouvé à l'index ${i}`);
        trouve = true;
        break;  // Arrête la boucle
    }
}

if (!trouve) {
    console.log(`${cible} non trouvé`);
}

L'instruction continue

Passe à l'itération suivante en sautant le reste du bloc.

// Afficher seulement les nombres pairs
for (let i = 1; i <= 10; i++) {
    if (i % 2 === 1) {
        continue;  // Ignore les nombres impairs
    }
    console.log(`Nombre pair: ${i}`);
}

// Sortie : 2, 4, 6, 8, 10

Boucles imbriquées

// Créer une table de multiplication
for (let i = 1; i <= 3; i++) {
    console.log(`Table de ${i}:`);
    for (let j = 1; j <= 5; j++) {
        console.log(`  ${i} x ${j} = ${i * j}`);
    }
}

// Parcourir un tableau 2D
let matrice = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];

for (let i = 0; i < matrice.length; i++) {
    for (let j = 0; j < matrice[i].length; j++) {
        console.log(`matrice[${i}][${j}] = ${matrice[i][j]}`);
    }
}

Cas pratiques et exercices

Calcul de statistiques

let notes = [15, 18, 12, 16, 14, 19, 11];
let somme = 0;
let max = notes[0];
let min = notes[0];

for (let note of notes) {
    somme += note;
    if (note > max) max = note;
    if (note < min) min = note;
}

let moyenne = somme / notes.length;

console.log(`Moyenne: ${moyenne.toFixed(2)}`);
console.log(`Note max: ${max}`);
console.log(`Note min: ${min}`);

Traitement de chaînes

let phrase = "JavaScript est formidable";
let voyelles = "aeiouAEIOU";
let compteurVoyelles = 0;

for (let caractere of phrase) {
    if (voyelles.includes(caractere)) {
        compteurVoyelles++;
    }
}

console.log(`La phrase contient ${compteurVoyelles} voyelles`);

Génération de motifs

// Créer un sapin
let hauteur = 5;

for (let i = 1; i <= hauteur; i++) {
    let espaces = " ".repeat(hauteur - i);
    let etoiles = "*".repeat(2 * i - 1);
    console.log(espaces + etoiles);
}

// Sortie :
//     *
//    ***
//   *****
//  *******
// *********

Les Fonctions

Qu'est-ce qu'une fonction ?

Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique. Les fonctions permettent d'organiser le code, d'éviter la répétition, et de créer des programmes modulaires et maintenables.

Analogie : Une fonction c'est comme une machine qui prend des ingrédients (paramètres), les traite, et produit un résultat.

Déclaration de fonctions

Syntaxe de base

function nomDeLaFonction(parametre1, parametre2) {
    // Corps de la fonction
    // Instructions à exécuter
    return resultat;  // Optionnel
}

Exemple simple

function saluer(nom) {
    return `Bonjour ${nom} !`;
}

// Appel de la fonction
let message = saluer("Alice");
console.log(message);  // "Bonjour Alice !"

Types de fonctions

1. Déclaration de fonction (Function Declaration)

function calculerAire(longueur, largeur) {
    return longueur * largeur;
}

// Peut être appelée avant sa déclaration (hoisting)
console.log(calculerAire(5, 3));  // 15

2. Expression de fonction (Function Expression)

const calculerPerimetre = function(longueur, largeur) {
    return 2 * (longueur + largeur);
};

// Doit être déclarée avant utilisation
console.log(calculerPerimetre(5, 3));  // 16

3. Fonction flèche (Arrow Function) - ES6+

// Syntaxe courte
const doubler = (nombre) => nombre * 2;

// Syntaxe complète
const calculerMoyenne = (a, b, c) => {
    let somme = a + b + c;
    return somme / 3;
};

console.log(doubler(4));           // 8
console.log(calculerMoyenne(10, 15, 20));  // 15

Paramètres et arguments

Paramètres vs Arguments

// Les paramètres sont dans la déclaration
function presenter(nom, age) {  // nom et age sont des paramètres
    return `Je m'appelle ${nom} et j'ai ${age} ans`;
}

// Les arguments sont dans l'appel
let presentation = presenter("Bob", 25);  // "Bob" et 25 sont des arguments

Paramètres par défaut

function saluer(nom = "Invité", moment = "journée") {
    return `Bonjour ${nom}, bonne ${moment} !`;
}

console.log(saluer());                    // "Bonjour Invité, bonne journée !"
console.log(saluer("Alice"));            // "Bonjour Alice, bonne journée !"
console.log(saluer("Bob", "soirée"));    // "Bonjour Bob, bonne soirée !"

Nombre variable de paramètres (Rest Parameters)

function additionner(...nombres) {
    let somme = 0;
    for (let nombre of nombres) {
        somme += nombre;
    }
    return somme;
}

console.log(additionner(1, 2, 3));         // 6
console.log(additionner(5, 10, 15, 20));   // 50

La valeur de retour

Fonction avec retour

function calculerTTC(prixHT, tauxTVA = 0.20) {
    return prixHT * (1 + tauxTVA);
}

let prixFinal = calculerTTC(100);  // 120
console.log(`Prix TTC: ${prixFinal}€`);

Fonction sans retour (procédure)

function afficherInfos(nom, age) {
    console.log("=== INFORMATIONS ===");
    console.log(`Nom: ${nom}`);
    console.log(`Age: ${age}`);
    console.log("==================");
    // Pas de return -> retourne undefined
}

afficherInfos("Charlie", 30);

Retour anticipé

function validerAge(age) {
    if (age < 0) {
        return "Age invalide";
    }
    
    if (age < 18) {
        return "Mineur";
    }
    
    if (age >= 65) {
        return "Senior";
    }
    
    return "Adulte";
}

console.log(validerAge(-5));   // "Age invalide"
console.log(validerAge(16));   // "Mineur"
console.log(validerAge(30));   // "Adulte"

Portée des variables (Scope)

Variables locales vs globales

let variableGlobale = "Je suis globale";

function exemplePortee() {
    let variableLocale = "Je suis locale";
    
    console.log(variableGlobale);  // ✅ Accessible
    console.log(variableLocale);   // ✅ Accessible
}

exemplePortee();
console.log(variableGlobale);  // ✅ Accessible
// console.log(variableLocale);  ❌ Erreur ! Hors de portée

Masquage de variables

let nom = "Variable globale";

function test() {
    let nom = "Variable locale";  // Masque la variable globale
    console.log(nom);  // "Variable locale"
}

test();
console.log(nom);  // "Variable globale"

Fonctions avancées

Fonctions de rappel (Callbacks)

function traiterDonnees(donnees, callback) {
    console.log("Traitement en cours...");
    let resultat = donnees.map(x => x * 2);
    callback(resultat);
}

function afficherResultat(data) {
    console.log("Résultat:", data);
}

traiterDonnees([1, 2, 3, 4], afficherResultat);
// Traitement en cours...
// Résultat: [2, 4, 6, 8]

Fonctions récursives

function factorielle(n) {
    if (n <= 1) {
        return 1;  // Cas de base
    }
    return n * factorielle(n - 1);  // Appel récursif
}

console.log(factorielle(5));  // 120 (5 * 4 * 3 * 2 * 1)

Fonctions imbriquées et closures

function creerCompteur(valeurInitiale = 0) {
    let compteur = valeurInitiale;
    
    // Fonction imbriquée avec accès à la variable parente
    return function() {
        compteur++;
        return compteur;
    };
}

let compteur1 = creerCompteur(10);
let compteur2 = creerCompteur();

console.log(compteur1());  // 11
console.log(compteur1());  // 12
console.log(compteur2());  // 1
console.log(compteur2());  // 2

Bonnes pratiques

1. Une fonction = une tâche

// ❌ Fonction qui fait trop de choses
function gererUtilisateur(nom, email, age) {
    // Validation
    if (!nom || !email) return false;
    // Formatage
    nom = nom.trim().toLowerCase();
    // Calcul
    let estMajeur = age >= 18;
    // Affichage
    console.log(`Utilisateur: ${nom}`);
    // ...
}

// ✅ Séparer les responsabilités
function validerUtilisateur(nom, email) {
    return nom && email && email.includes("@");
}

function formaterNom(nom) {
    return nom.trim().toLowerCase();
}

function estMajeur(age) {
    return age >= 18;
}

2. Noms descriptifs

// ❌ Noms peu clairs
function calc(a, b) {
    return a * b * 0.2;
}

// ✅ Nom descriptif
function calculerRemiseVingtPourcent(prix, quantite) {
    return prix * quantite * 0.2;
}

3. Documentation

/**
 * Calcule la distance entre deux points
 * @param {number} x1 - Coordonnée X du premier point
 * @param {number} y1 - Coordonnée Y du premier point  
 * @param {number} x2 - Coordonnée X du deuxième point
 * @param {number} y2 - Coordonnée Y du deuxième point
 * @returns {number} La distance entre les deux points
 */
function calculerDistance(x1, y1, x2, y2) {
    return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
}

Exemples pratiques

Utilitaires mathématiques

const MathUtils = {
    max: (a, b) => a > b ? a : b,
    min: (a, b) => a < b ? a : b,
    
    estPair: (nombre) => nombre % 2 === 0,
    
    arrondir: (nombre, decimales = 0) => {
        const facteur = Math.pow(10, decimales);
        return Math.round(nombre * facteur) / facteur;
    }
};

console.log(MathUtils.max(10, 7));      // 10
console.log(MathUtils.estPair(4));      // true
console.log(MathUtils.arrondir(3.14159, 2));  // 3.14

Validation de formulaire

function validerFormulaire(donnees) {
    const erreurs = [];
    
    if (!donnees.nom || donnees.nom.length < 2) {
        erreurs.push("Le nom doit contenir au moins 2 caractères");
    }
    
    if (!donnees.email || !donnees.email.includes("@")) {
        erreurs.push("Email invalide");
    }
    
    if (!donnees.age || donnees.age < 0 || donnees.age > 120) {
        erreurs.push("Age invalide");
    }
    
    return {
        valide: erreurs.length === 0,
        erreurs: erreurs
    };
}

const resultat = validerFormulaire({
    nom: "Alice",
    email: "alice@test.com",
    age: 25
});

console.log(resultat);  // { valide: true, erreurs: [] }

Le DOM (Document Object Model)

Qu'est-ce que le DOM ?

Le DOM (Document Object Model) est une représentation en arbre de la structure HTML d'une page web. Il permet à JavaScript d'interagir avec les éléments HTML, de les modifier, de les styliser, et de réagir aux événements utilisateur.

Analogie : Le DOM c'est comme un plan détaillé de votre maison où chaque pièce, meuble et objet peut être localisé, modifié ou remplacé.

<!DOCTYPE html>
<html>
    <head>
        <title>Ma page</title>
    </head>
    <body>
        <h1 id="titre">Bonjour</h1>
        <p class="description">Ceci est un paragraphe</p>
        <button onclick="alert('Clic!')">Cliquer</button>
    </body>
</html>

Structure hiérarchique du DOM

Document
    └── html
        ├── head
        │   └── title
        │       └── "Ma page" (text node)
        └── body
            ├── h1 (id="titre")
            │   └── "Bonjour" (text node)  
            ├── p (class="description")
            │   └── "Ceci est un paragraphe" (text node)
            └── button
                └── "Cliquer" (text node)

Sélection d'éléments

Sélection par ID

// HTML: <h1 id="titre">Mon titre</h1>
let titre = document.getElementById("titre");
console.log(titre.textContent);  // "Mon titre"

Sélection par classe

// HTML: <p class="info">Information</p>
let elements = document.getElementsByClassName("info");
console.log(elements.length);  // Nombre d'éléments avec la classe "info"

// Parcourir tous les éléments avec cette classe
for (let i = 0; i < elements.length; i++) {
    console.log(elements[i].textContent);
}

Sélection par balise

// Sélectionner tous les paragraphes
let paragraphes = document.getElementsByTagName("p");
console.log(paragraphes[0].textContent);  // Premier paragraphe

Sélecteurs CSS modernes (recommandés)

querySelector() - Premier élément correspondant
// Sélection par ID
let titre = document.querySelector("#titre");

// Sélection par classe
let premierInfo = document.querySelector(".info");

// Sélection par balise
let premierParagraphe = document.querySelector("p");

// Sélecteurs complexes
let lienDansNav = document.querySelector("nav a");
let boutonRouge = document.querySelector("button.rouge");
querySelectorAll() - Tous les éléments correspondants
// Sélectionner tous les éléments avec la classe "info"
let tousLesInfos = document.querySelectorAll(".info");

// Parcourir avec forEach
tousLesInfos.forEach(element => {
    console.log(element.textContent);
});

// Sélecteur complexe
let liensExterne = document.querySelectorAll('a[href^="http"]');

Manipulation du contenu

textContent vs innerText vs innerHTML

// HTML: <p id="demo">Bonjour le <strong>monde</strong></p>
let paragraphe = document.querySelector("#demo");

console.log(paragraphe.textContent);  // "Bonjour le monde"
console.log(paragraphe.innerText);    // "Bonjour le monde" 
console.log(paragraphe.innerHTML);    // "Bonjour le <strong>monde</strong>"

Différences importantes :

Modification du contenu

let titre = document.querySelector("h1");

// Modifier le texte
titre.textContent = "Nouveau titre";

// Modifier le HTML
titre.innerHTML = "Titre avec <em>style</em>";

// Ajouter du contenu
let conteneur = document.querySelector("#conteneur");
conteneur.innerHTML += "<p>Nouveau paragraphe</p>";

Manipulation des attributs

getAttribute() et setAttribute()

// HTML: <img id="photo" src="image1.jpg" alt="Photo" class="grande">
let image = document.querySelector("#photo");

// Lire des attributs
console.log(image.getAttribute("src"));     // "image1.jpg"
console.log(image.getAttribute("alt"));     // "Photo"

// Modifier des attributs
image.setAttribute("src", "image2.jpg");
image.setAttribute("title", "Belle photo");

// Supprimer un attribut
image.removeAttribute("class");

Propriétés directes

let lien = document.querySelector("a");

// Équivalents plus directs
console.log(lien.href);     // Au lieu de getAttribute("href")
console.log(lien.id);       // Au lieu de getAttribute("id")
console.log(lien.className);// Au lieu de getAttribute("class")

// Modification
lien.href = "https://example.com";
lien.target = "_blank";

Manipulation du style

Style en ligne

let element = document.querySelector("#monElement");

// Modifier des propriétés CSS individuelles
element.style.color = "red";
element.style.fontSize = "18px";
element.style.backgroundColor = "yellow";
element.style.border = "2px solid blue";

// Propriétés avec tirets -> camelCase
element.style.marginTop = "20px";     // margin-top
element.style.textAlign = "center";   // text-align

Manipulation des classes CSS

let element = document.querySelector(".box");

// Ajouter une classe
element.classList.add("active");
element.classList.add("highlight", "important");  // Plusieurs à la fois

// Supprimer une classe
element.classList.remove("old-class");

// Basculer une classe (toggle)
element.classList.toggle("visible");  // Ajoute si absente, supprime si présente

// Vérifier la présence d'une classe
if (element.classList.contains("active")) {
    console.log("L'élément est actif");
}

// Remplacer une classe
element.classList.replace("old", "new");

Relations entre éléments

// HTML:
// <div id="parent">
//     <p id="premier">Premier</p>
//     <p id="deuxieme">Deuxième</p>
//     <p id="troisieme">Troisième</p>
// </div>

let deuxieme = document.querySelector("#deuxieme");

// Éléments parents
console.log(deuxieme.parentNode);        // div#parent
console.log(deuxieme.parentElement);     // div#parent (recommandé)

// Éléments enfants (depuis le parent)
let parent = document.querySelector("#parent");
console.log(parent.children);            // Collection des éléments enfants
console.log(parent.firstElementChild);   // Premier enfant <p>
console.log(parent.lastElementChild);    // Dernier enfant <p>

// Éléments frères/sœurs
console.log(deuxieme.previousElementSibling);  // <p id="premier">
console.log(deuxieme.nextElementSibling);      // <p id="troisieme">

Création et suppression d'éléments

Créer de nouveaux éléments

// Créer un élément
let nouveauParagraphe = document.createElement("p");
nouveauParagraphe.textContent = "Nouveau contenu";
nouveauParagraphe.className = "nouveau";

// Créer un élément avec attributs
let lien = document.createElement("a");
lien.href = "https://example.com";
lien.textContent = "Visiter le site";
lien.target = "_blank";

console.log(nouveauParagraphe);  // <p class="nouveau">Nouveau contenu</p>

Ajouter des éléments au DOM

let conteneur = document.querySelector("#conteneur");

// Ajouter à la fin
conteneur.appendChild(nouveauParagraphe);

// Insérer à une position spécifique
let premierEnfant = conteneur.firstElementChild;
conteneur.insertBefore(lien, premierEnfant);  // Insérer avant le premier enfant

// Méthodes modernes
conteneur.prepend(nouveauParagraphe);    // Au début
conteneur.append(lien);                  // À la fin
premierEnfant.before(nouveauParagraphe); // Avant un élément
premierEnfant.after(lien);               // Après un élément

Supprimer des éléments

let elementASupprimer = document.querySelector("#aSupprimer");

// Méthode moderne (recommandée)
elementASupprimer.remove();

// Méthode classique
let parent = elementASupprimer.parentNode;
parent.removeChild(elementASupprimer);

// Vider un conteneur
let conteneur = document.querySelector("#conteneur");
conteneur.innerHTML = "";  // Simple mais pas optimal
// ou
while (conteneur.firstChild) {
    conteneur.removeChild(conteneur.firstChild);
}

Exemples pratiques

Créer une liste dynamique

function creerListeProduits(produits) {
    let liste = document.createElement("ul");
    liste.className = "liste-produits";
    
    produits.forEach(produit => {
        let item = document.createElement("li");
        item.innerHTML = `
            <h3>${produit.nom}</h3>
            <p>Prix: ${produit.prix}€</p>
            <button onclick="acheter(${produit.id})">Acheter</button>
        `;
        liste.appendChild(item);
    });
    
    return liste;
}

// Utilisation
let produits = [
    { id: 1, nom: "Laptop", prix: 999 },
    { id: 2, nom: "Souris", prix: 25 },
    { id: 3, nom: "Clavier", prix: 75 }
];

let conteneur = document.querySelector("#produits");
let listeProduits = creerListeProduits(produits);
conteneur.appendChild(listeProduits);

Formulaire dynamique

function validerFormulaire() {
    let nom = document.querySelector("#nom").value;
    let email = document.querySelector("#email").value;
    let messageErreur = document.querySelector("#erreur");
    
    // Réinitialiser les erreurs
    messageErreur.textContent = "";
    messageErreur.style.display = "none";
    
    // Validation
    if (!nom.trim()) {
        afficherErreur("Le nom est obligatoire");
        return false;
    }
    
    if (!email.includes("@")) {
        afficherErreur("Email invalide");
        return false;
    }
    
    return true;
}

function afficherErreur(message) {
    let messageErreur = document.querySelector("#erreur");
    messageErreur.textContent = message;
    messageErreur.style.display = "block";
    messageErreur.style.color = "red";
}

Carrousel d'images

class Carrousel {
    constructor(conteneur, images) {
        this.conteneur = conteneur;
        this.images = images;
        this.indexActuel = 0;
        this.creerInterface();
    }
    
    creerInterface() {
        // Créer l'image principale
        this.imageElement = document.createElement("img");
        this.imageElement.src = this.images[0];
        this.imageElement.className = "carrousel-image";
        
        // Créer les boutons
        let boutonPrecedent = document.createElement("button");
        boutonPrecedent.textContent = "◀";
        boutonPrecedent.onclick = () => this.precedent();
        
        let boutonSuivant = document.createElement("button");
        boutonSuivant.textContent = "▶";
        boutonSuivant.onclick = () => this.suivant();
        
        // Assembler l'interface
        this.conteneur.appendChild(boutonPrecedent);
        this.conteneur.appendChild(this.imageElement);
        this.conteneur.appendChild(boutonSuivant);
    }
    
    precedent() {
        this.indexActuel = (this.indexActuel - 1 + this.images.length) % this.images.length;
        this.mettreAJour();
    }
    
    suivant() {
        this.indexActuel = (this.indexActuel + 1) % this.images.length;
        this.mettreAJour();
    }
    
    mettreAJour() {
        this.imageElement.src = this.images[this.indexActuel];
    }
}

// Utilisation
let conteneur = document.querySelector("#carrousel");
let images = ["image1.jpg", "image2.jpg", "image3.jpg"];
let monCarrousel = new Carrousel(conteneur, images);

Les Événements

Qu'est-ce qu'un événement ?

Un événement est une action qui se produit dans le navigateur, comme un clic de souris, une pression de touche, ou le chargement d'une page. JavaScript permet de "écouter" ces événements et d'y réagir avec du code personnalisé.

Analogie : Les événements sont comme des signaux d'alarme dans votre maison. Quand quelqu'un sonne à la porte (événement), vous entendez la sonnette (écouteur) et vous allez ouvrir (fonction de réponse).

Types d'événements courants

Événements de souris

Événements de clavier

Événements de formulaire

Événements de fenêtre

Méthodes d'ajout d'événements

1. Événements inline (à éviter)

<!-- ❌ Déconseillé : mélange HTML et JavaScript -->
<button onclick="alert('Cliqué!')">Cliquer</button>

2. Propriétés d'événement

let bouton = document.querySelector("#monBouton");

// ⚠️ Limitation : une seule fonction par événement
bouton.onclick = function() {
    alert("Bouton cliqué !");
};

// Cette fonction remplace la précédente
bouton.onclick = function() {
    console.log("Nouvelle fonction");
};

3. addEventListener() (recommandée)

let bouton = document.querySelector("#monBouton");

// ✅ Méthode recommandée
bouton.addEventListener("click", function() {
    alert("Bouton cliqué !");
});

// Plusieurs écouteurs possibles
bouton.addEventListener("click", function() {
    console.log("Deuxième fonction");
});

bouton.addEventListener("click", changerCouleur);

function changerCouleur() {
    bouton.style.backgroundColor = "red";
}

L'objet Event

Chaque événement génère un objet Event contenant des informations sur ce qui s'est passé :

document.addEventListener("click", function(event) {
    console.log("Type d'événement:", event.type);        // "click"
    console.log("Élément cible:", event.target);         // Élément cliqué
    console.log("Position X:", event.clientX);           // Position de la souris
    console.log("Position Y:", event.clientY);
    console.log("Touches modif:", event.ctrlKey);        // Ctrl enfoncé ?
});

Propriétés utiles de l'objet Event

button.addEventListener("click", function(event) {
    // Informations générales
    console.log(event.type);          // Type d'événement
    console.log(event.target);        // Élément qui a déclenché l'événement
    console.log(event.currentTarget); // Élément avec l'écouteur
    console.log(event.timeStamp);     // Moment de l'événement
    
    // Informations sur la souris
    console.log(event.clientX, event.clientY);  // Position relative à la fenêtre
    console.log(event.pageX, event.pageY);      // Position relative à la page
    console.log(event.button);                  // Bouton de souris (0=gauche, 1=milieu, 2=droite)
    
    // Touches modificatrices
    console.log(event.ctrlKey);       // Ctrl enfoncé
    console.log(event.shiftKey);      // Shift enfoncé
    console.log(event.altKey);        // Alt enfoncé
});

Le mot-clé this dans les événements

let boutons = document.querySelectorAll(".bouton");

boutons.forEach(bouton => {
    bouton.addEventListener("click", function() {
        // `this` fait référence à l'élément qui a déclenché l'événement
        this.style.backgroundColor = "green";
        this.textContent = "Cliqué !";
        console.log("ID du bouton:", this.id);
    });
});

// ⚠️ Attention avec les arrow functions
bouton.addEventListener("click", (event) => {
    // `this` ne fonctionne pas comme attendu avec les arrow functions
    // Utilisez event.target à la place
    event.target.style.backgroundColor = "green";
});

Propagation des événements

Event Bubbling

Les événements "remontent" de l'élément cible vers ses parents :

<div id="parent">
    <div id="enfant">
        <button id="bouton">Cliquer</button>
    </div>
</div>
document.getElementById("parent").addEventListener("click", function() {
    console.log("Parent cliqué");
});

document.getElementById("enfant").addEventListener("click", function() {
    console.log("Enfant cliqué");
});

document.getElementById("bouton").addEventListener("click", function() {
    console.log("Bouton cliqué");
});

// Cliquer sur le bouton affiche :
// "Bouton cliqué"
// "Enfant cliqué"  
// "Parent cliqué"

Arrêter la propagation

document.getElementById("bouton").addEventListener("click", function(event) {
    console.log("Bouton cliqué");
    event.stopPropagation();  // Empêche la remontée
});

// Maintenant, seul "Bouton cliqué" s'affiche

Event Delegation

Technique efficace pour gérer les événements sur des éléments dynamiques :

// Au lieu d'ajouter un écouteur à chaque bouton
document.getElementById("conteneur").addEventListener("click", function(event) {
    // Vérifier si l'élément cliqué est un bouton
    if (event.target.matches("button.supprimer")) {
        let produit = event.target.closest(".produit");
        produit.remove();
    }
    
    if (event.target.matches("button.ajouter")) {
        let produit = event.target.closest(".produit");
        ajouterAuPanier(produit.dataset.id);
    }
});

// Avantages :
// 1. Un seul écouteur pour tous les boutons
// 2. Fonctionne avec les éléments ajoutés dynamiquement
// 3. Meilleures performances

Événements de formulaire

Validation en temps réel

let formulaire = document.querySelector("#monFormulaire");
let champEmail = document.querySelector("#email");
let champMotDePasse = document.querySelector("#motDePasse");

// Validation au fur et à mesure
champEmail.addEventListener("input", function() {
    let email = this.value;
    let messageErreur = document.querySelector("#erreurEmail");
    
    if (email && !email.includes("@")) {
        messageErreur.textContent = "Format d'email invalide";
        messageErreur.style.display = "block";
        this.style.borderColor = "red";
    } else {
        messageErreur.style.display = "none";
        this.style.borderColor = "green";
    }
});

// Validation à la soumission
formulaire.addEventListener("submit", function(event) {
    event.preventDefault();  // Empêche la soumission par défaut
    
    if (validerFormulaire()) {
        console.log("Formulaire valide, envoi en cours...");
        // Traitement des données
    } else {
        console.log("Formulaire invalide");
    }
});

function validerFormulaire() {
    let email = champEmail.value;
    let motDePasse = champMotDePasse.value;
    
    return email.includes("@") && motDePasse.length >= 6;
}

Événements change vs input

let champ = document.querySelector("#monChamp");

// `input` : Se déclenche à chaque caractère tapé
champ.addEventListener("input", function() {
    console.log("Valeur actuelle :", this.value);
});

// `change` : Se déclenche quand l'élément perd le focus ET que la valeur a changé
champ.addEventListener("change", function() {
    console.log("Valeur finale :", this.value);
});

Événements de clavier

document.addEventListener("keydown", function(event) {
    console.log("Touche pressée :", event.key);
    console.log("Code de la touche :", event.code);
    
    // Raccourcis clavier
    if (event.ctrlKey && event.key === "s") {
        event.preventDefault();  // Empêche Ctrl+S du navigateur
        sauvegarder();
    }
    
    // Navigation avec les flèches
    switch(event.code) {
        case "ArrowUp":
            deplacerHaut();
            break;
        case "ArrowDown":
            deplacerBas();
            break;
        case "ArrowLeft":
            deplacerGauche();
            break;
        case "ArrowRight":
            deplacerDroite();
            break;
        case "Escape":
            fermerModal();
            break;
    }
});

Suppression d'événements

let bouton = document.querySelector("#bouton");

function gestionnaireClick() {
    console.log("Bouton cliqué");
}

// Ajouter l'écouteur
bouton.addEventListener("click", gestionnaireClick);

// Supprimer l'écouteur (doit être la même fonction)
bouton.removeEventListener("click", gestionnaireClick);

// ⚠️ Ceci ne fonctionne pas (fonctions différentes) :
bouton.addEventListener("click", function() { console.log("Test"); });
bouton.removeEventListener("click", function() { console.log("Test"); });

Exemples pratiques avancés

Galerie d'images interactive

class GalerieImages {
    constructor(conteneur) {
        this.conteneur = conteneur;
        this.images = [];
        this.indexActuel = 0;
        this.initier();
    }
    
    initier() {
        // Créer la structure
        this.conteneur.innerHTML = `
            <div class="galerie-principale">
                <img id="imageActuelle" src="" alt="Image actuelle">
                <div class="controles">
                    <button id="precedent">◀</button>
                    <button id="suivant">▶</button>
                </div>
            </div>
            <div class="vignettes"></div>
        `;
        
        // Ajouter les écouteurs
        this.ajouterEcouteurs();
    }
    
    ajouterEcouteurs() {
        // Boutons de navigation
        document.getElementById("precedent").addEventListener("click", () => {
            this.afficherImage(this.indexActuel - 1);
        });
        
        document.getElementById("suivant").addEventListener("click", () => {
            this.afficherImage(this.indexActuel + 1);
        });
        
        // Navigation clavier
        document.addEventListener("keydown", (event) => {
            if (event.code === "ArrowLeft") this.afficherImage(this.indexActuel - 1);
            if (event.code === "ArrowRight") this.afficherImage(this.indexActuel + 1);
        });
        
        // Clic sur vignettes (event delegation)
        document.querySelector(".vignettes").addEventListener("click", (event) => {
            if (event.target.matches(".vignette")) {
                let index = parseInt(event.target.dataset.index);
                this.afficherImage(index);
            }
        });
    }
    
    chargerImages(urlImages) {
        this.images = urlImages;
        this.creerVignettes();
        this.afficherImage(0);
    }
    
    creerVignettes() {
        let conteneurVignettes = document.querySelector(".vignettes");
        conteneurVignettes.innerHTML = "";
        
        this.images.forEach((url, index) => {
            let vignette = document.createElement("img");
            vignette.src = url;
            vignette.className = "vignette";
            vignette.dataset.index = index;
            conteneurVignettes.appendChild(vignette);
        });
    }
    
    afficherImage(index) {
        // Gérer les limites
        if (index < 0) index = this.images.length - 1;
        if (index >= this.images.length) index = 0;
        
        this.indexActuel = index;
        
        // Mettre à jour l'image principale
        document.getElementById("imageActuelle").src = this.images[index];
        
        // Mettre à jour les vignettes
        document.querySelectorAll(".vignette").forEach((vignette, i) => {
            vignette.classList.toggle("active", i === index);
        });
    }
}

// Utilisation
let galerie = new GalerieImages(document.querySelector("#galerie"));
galerie.chargerImages([
    "image1.jpg",
    "image2.jpg", 
    "image3.jpg"
]);

Drag and Drop

class DragDrop {
    constructor() {
        this.initier();
    }
    
    initier() {
        let elements = document.querySelectorAll(".draggable");
        let zones = document.querySelectorAll(".drop-zone");
        
        // Éléments déplaçables
        elements.forEach(element => {
            element.draggable = true;
            element.addEventListener("dragstart", this.onDragStart.bind(this));
        });
        
        // Zones de dépôt
        zones.forEach(zone => {
            zone.addEventListener("dragover", this.onDragOver.bind(this));
            zone.addEventListener("drop", this.onDrop.bind(this));
        });
    }
    
    onDragStart(event) {
        event.dataTransfer.setData("text/plain", event.target.id);
        event.target.style.opacity = "0.5";
    }
    
    onDragOver(event) {
        event.preventDefault();  // Autoriser le drop
        event.currentTarget.classList.add("drag-over");
    }
    
    onDrop(event) {
        event.preventDefault();
        
        let elementId = event.dataTransfer.getData("text/plain");
        let element = document.getElementById(elementId);
        
        event.currentTarget.appendChild(element);
        element.style.opacity = "1";
        event.currentTarget.classList.remove("drag-over");
    }
}

new DragDrop();