Cours2
Cours JavaScript pour Débutants - Guide Complet
Table des Matières
- Introduction au JavaScript
- Les Types de Données Primitifs
- Les Variables
- Les Chaînes de Caractères
- Les Opérateurs de Comparaison
- Les Structures Conditionnelles
- Les Tableaux
- Les Objets
- Les Boucles
- Les Fonctions
- Le DOM (Document Object Model)
- 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 :
- Le développement web côté client (navigateur)
- Le développement web côté serveur (Node.js)
- Les applications mobiles hybrides
- Les applications de bureau
- L'Internet des objets (IoT)
Les trois piliers du développement web
HTML → Structure (le squelette)
CSS → Présentation (l'apparence)
JS → Comportement (l'interactivité)
Exemple concret :
- HTML : Crée un bouton
<button>Cliquer</button> - CSS : Rend le bouton rouge
button { color: red; } - JavaScript : Fait que le bouton réponde au clic
button.onclick = () => alert("Bonjour!");
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 :
- Commencer par une lettre,
_ou$ - Contenir uniquement des lettres, chiffres,
_ou$ - Pas d'espaces ni de caractères spéciaux
- Sensible à la casse (
maVariable≠mavariable)
Bonnes pratiques :
- Utiliser le camelCase :
monNomDeVariable - Choisir des noms descriptifs :
ageUtilisateurplutôt quex - Utiliser l'anglais pour la cohérence
- Les constantes en MAJUSCULES :
TAUX_TVA
// ✅ 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
- Initialisation (
let i = 0) : Exécutée une seule fois au début - Condition (
i < 5) : Vérifiée avant chaque itération - Bloc de code : Exécuté si la condition est vraie
- 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 :
- textContent : Récupère/définit tout le texte, y compris les éléments masqués
- innerText : Respecte le style CSS (éléments masqués exclus)
- innerHTML : Inclut les balises HTML
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
Naviguer dans le DOM
// 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
click: Clic simpledblclick: Double-clicmousedown: Bouton de souris enfoncémouseup: Bouton de souris relâchémouseover: Souris entre dans l'élémentmouseout: Souris sort de l'élémentmousemove: Souris se déplace sur l'élément
Événements de clavier
keydown: Touche enfoncéekeyup: Touche relâchéekeypress: Touche pressée (déprécié)
Événements de formulaire
submit: Soumission du formulairechange: Valeur d'un champ modifiéeinput: Saisie en temps réelfocus: Élément reçoit le focusblur: Élément perd le focus
Événements de fenêtre
load: Page entièrement chargéeresize: Taille de fenêtre modifiéescroll: Défilement de page
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();