Bye Bye Prof

Cours

Cours JavaScript pour Débutants

Table des matières

  1. Introduction à JavaScript
  2. Types de données et variables
  3. Opérateurs et comparaisons
  4. Structures conditionnelles
  5. Boucles
  6. Tableaux
  7. Fonctions
  8. Objets
  9. DOM et événements
  10. Projets pratiques

Introduction à JavaScript

JavaScript est un langage de programmation créé en 1995 par Brendan Eich chez Netscape. Initialement conçu pour rendre les pages web interactives, JavaScript est devenu l'un des langages les plus populaires au monde.

Pourquoi apprendre JavaScript ?

Où écrire du JavaScript ?

  1. Console du navigateur (F12 → Console)
  2. Fichiers .js liés à une page HTML
  3. Éditeurs en ligne (CodePen, JSFiddle)
<!DOCTYPE html>
<html>
<head>
    <title>Ma première page JavaScript</title>
</head>
<body>
    <h1>Bonjour le monde !</h1>
    <script>
        console.log("Hello World!");
        alert("Bienvenue en JavaScript !");
    </script>
</body>
</html>

Types de données et variables

Les types primitifs

JavaScript a 6 types primitifs principaux :

1. Number (Nombres)

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

// Opérations mathématiques
console.log(10 + 5);    // 15
console.log(10 - 5);    // 5
console.log(10 * 5);    // 50
console.log(10 / 5);    // 2
console.log(10 % 3);    // 1 (modulo - reste de la division)

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

let nom = "Alice";
let prenom = 'Bob';
let phrase = "Il a dit : 'Bonjour !'";

// Concaténation (ancienne méthode)
let nomComplet = prenom + " " + nom;

// Template literals (méthode moderne - recommandée)
let presentation = `Je m'appelle ${prenom} ${nom} et j'ai ${age} ans.`;

// Propriétés et méthodes utiles
console.log(nom.length);              // 5
console.log(nom.toUpperCase());       // "ALICE"
console.log(nom.toLowerCase());       // "alice"
console.log(phrase.includes("dit"));  // true

3. Boolean (Booléens)

let estMajeur = true;
let estMineur = false;

// Valeurs "falsy" (évaluées comme false)
console.log(Boolean(false));    // false
console.log(Boolean(0));        // false
console.log(Boolean(""));       // false
console.log(Boolean(null));     // false
console.log(Boolean(undefined)); // false
console.log(Boolean(NaN));      // false

// Valeurs "truthy" (évaluées comme true)
console.log(Boolean(true));     // true
console.log(Boolean(1));        // true
console.log(Boolean("hello")); // true
console.log(Boolean([]));       // true (tableau vide)
console.log(Boolean({}));       // true (objet vide)

4. Undefined et Null

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

let variableNulle = null;
console.log(variableNulle);      // null

// Différence importante
console.log(typeof undefined);   // "undefined"
console.log(typeof null);        // "object" (bug historique de JavaScript!)

Déclaration des variables

// const : pour les valeurs qui ne changent pas (recommandé par défaut)
const PI = 3.14159;
const COULEUR_PRIMAIRE = "bleu";

// let : pour les valeurs qui peuvent changer
let compteur = 0;
let nom = "Marie";
nom = "Pierre"; // OK

// var : ancienne syntaxe (à éviter)
var ancienneVariable = "évitez var";

// Bonnes pratiques
const utilisateur = {
    nom: "Alice",
    age: 30
};
// On peut modifier les propriétés d'un objet const
utilisateur.age = 31; // OK
// Mais pas réassigner l'objet entier
// utilisateur = {}; // ❌ Erreur !

L'objet Math

// Méthodes utiles
console.log(Math.round(4.7));    // 5 (arrondi)
console.log(Math.floor(4.7));    // 4 (arrondi vers le bas)
console.log(Math.ceil(4.2));     // 5 (arrondi vers le haut)
console.log(Math.random());      // Nombre aléatoire entre 0 et 1

// Générer un nombre aléatoire entre 1 et 10
const nombreAleatoire = Math.floor(Math.random() * 10) + 1;

// Autres méthodes utiles
console.log(Math.max(5, 10, 15)); // 15
console.log(Math.min(5, 10, 15)); // 5
console.log(Math.abs(-5));        // 5
console.log(Math.pow(2, 3));      // 8 (2 puissance 3)

Opérateurs et comparaisons

Opérateurs arithmétiques

let a = 10;
let b = 3;

console.log(a + b);  // 13 (addition)
console.log(a - b);  // 7  (soustraction)
console.log(a * b);  // 30 (multiplication)
console.log(a / b);  // 3.333... (division)
console.log(a % b);  // 1  (modulo)
console.log(a ** b); // 1000 (exponentiation)

// Opérateurs d'assignation
let compteur = 5;
compteur += 3;  // compteur = compteur + 3 → 8
compteur -= 2;  // compteur = compteur - 2 → 6
compteur *= 2;  // compteur = compteur * 2 → 12
compteur++;     // compteur = compteur + 1 → 13
compteur--;     // compteur = compteur - 1 → 12

Opérateurs de comparaison

let x = 5;
let y = "5";

// Égalité faible (avec conversion de type)
console.log(x == y);   // true (5 == "5")

// Égalité stricte (sans conversion - RECOMMANDÉE)
console.log(x === y);  // false (5 !== "5")

// Inégalité
console.log(x != y);   // false
console.log(x !== y);  // true

// Comparaisons numériques
console.log(x > 3);    // true
console.log(x < 10);   // true
console.log(x >= 5);   // true
console.log(x <= 4);   // false

Opérateurs logiques

let age = 25;
let aPermis = true;

// ET logique (&&)
if (age >= 18 && aPermis) {
    console.log("Peut conduire");
}

// OU logique (||)
if (age < 18 || !aPermis) {
    console.log("Ne peut pas conduire");
}

// NON logique (!)
console.log(!true);     // false
console.log(!false);    // true
console.log(!"hello");  // false
console.log(!"");       // true

Structures conditionnelles

if, else if, else

const age = 20;
const aPermis = true;

if (age < 16) {
    console.log("Trop jeune pour conduire");
} else if (age < 18) {
    console.log("Peut conduire avec supervision");
} else if (aPermis) {
    console.log("Peut conduire seul");
} else {
    console.log("Doit passer le permis");
}

// Opérateur ternaire (condition courte)
const statut = age >= 18 ? "majeur" : "mineur";
console.log(`Cette personne est ${statut}`);

switch

const jour = "mardi";

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("Presque le weekend !");
        break;
    case "samedi":
    case "dimanche":
        console.log("Weekend !");
        break;
    default:
        console.log("Jour non reconnu");
}

Exercice pratique : Système de notes

function attribuerMention(note) {
    if (note >= 16) {
        return "Très bien";
    } else if (note >= 14) {
        return "Bien";
    } else if (note >= 12) {
        return "Assez bien";
    } else if (note >= 10) {
        return "Passable";
    } else {
        return "Insuffisant";
    }
}

console.log(attribuerMention(15)); // "Bien"

Boucles

Boucle for

// Boucle classique
for (let i = 0; i < 5; i++) {
    console.log(`Tour ${i + 1}`);
}

// Exemple pratique : table de multiplication
const nombre = 7;
for (let i = 1; i <= 10; i++) {
    console.log(`${nombre} × ${i} = ${nombre * i}`);
}

Boucle while

let compteur = 0;
while (compteur < 3) {
    console.log(`Compteur: ${compteur}`);
    compteur++;
}

// Attention aux boucles infinies !
// while (true) {
//     console.log("Cette boucle ne s'arrête jamais !"); // ❌ À éviter
// }

Boucle do...while

let reponse;
do {
    reponse = prompt("Tapez 'sortir' pour quitter:");
    console.log(`Vous avez tapé: ${reponse}`);
} while (reponse !== "sortir");

for...of (pour les tableaux)

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

for (const fruit of fruits) {
    console.log(`J'aime les ${fruit}s`);
}

for...in (pour les objets)

const personne = {
    nom: "Alice",
    age: 30,
    ville: "Paris"
};

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

break et continue

// break : sort de la boucle
for (let i = 0; i < 10; i++) {
    if (i === 5) {
        break; // Sort de la boucle quand i = 5
    }
    console.log(i); // Affiche 0, 1, 2, 3, 4
}

// continue : passe à l'itération suivante
for (let i = 0; i < 5; i++) {
    if (i === 2) {
        continue; // Ignore quand i = 2
    }
    console.log(i); // Affiche 0, 1, 3, 4
}

Tableaux

Création et accès

// Création
const fruits = ["pomme", "banane", "orange"];
const nombres = [1, 2, 3, 4, 5];
const mixte = ["texte", 42, true, null];

// Accès aux éléments
console.log(fruits[0]);        // "pomme"
console.log(fruits.length);    // 3
console.log(fruits[fruits.length - 1]); // "orange" (dernier élément)

Méthodes essentielles

let animaux = ["chat", "chien"];

// Ajouter des éléments
animaux.push("poisson");         // Ajoute à la fin
animaux.unshift("oiseau");       // Ajoute au début
console.log(animaux); // ["oiseau", "chat", "chien", "poisson"]

// Supprimer des éléments
let dernier = animaux.pop();     // Supprime et retourne le dernier
let premier = animaux.shift();   // Supprime et retourne le premier
console.log(animaux); // ["chat", "chien"]

// Recherche
const position = animaux.indexOf("chat");     // 0
const existe = animaux.includes("chat");      // true

// Modifier le tableau
animaux[0] = "félin";
console.log(animaux); // ["félin", "chien"]

Méthodes avancées

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

// map : transforme chaque élément
const doubles = nombres.map(n => n * 2);
console.log(doubles); // [2, 4, 6, 8, 10]

// filter : filtre selon une condition
const pairs = nombres.filter(n => n % 2 === 0);
console.log(pairs); // [2, 4]

// find : trouve le premier élément qui correspond
const premierPair = nombres.find(n => n % 2 === 0);
console.log(premierPair); // 2

// reduce : réduit à une valeur
const somme = nombres.reduce((total, n) => total + n, 0);
console.log(somme); // 15

// forEach : exécute une fonction pour chaque élément
nombres.forEach(n => console.log(`Nombre: ${n}`));

Tableaux multidimensionnels

const matrice = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];

console.log(matrice[1][2]); // 6

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

Exercice pratique : Gestion d'une liste de courses

const listeCourses = [];

function ajouterArticle(article) {
    if (!listeCourses.includes(article)) {
        listeCourses.push(article);
        console.log(`${article} ajouté à la liste`);
    } else {
        console.log(`${article} est déjà dans la liste`);
    }
}

function supprimerArticle(article) {
    const index = listeCourses.indexOf(article);
    if (index > -1) {
        listeCourses.splice(index, 1);
        console.log(`${article} supprimé de la liste`);
    }
}

function afficherListe() {
    console.log("Liste de courses:");
    listeCourses.forEach((article, index) => {
        console.log(`${index + 1}. ${article}`);
    });
}

// Test
ajouterArticle("pain");
ajouterArticle("lait");
ajouterArticle("œufs");
afficherListe();

Fonctions

Déclaration et appel

// Déclaration de fonction
function saluer(nom) {
    return `Bonjour ${nom} !`;
}

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

// Fonction sans paramètre
function direBonjour() {
    console.log("Bonjour tout le monde !");
}

direBonjour(); // "Bonjour tout le monde !"

Paramètres et arguments

// Paramètres par défaut
function calculerSurface(longueur, largeur = 1) {
    return longueur * largeur;
}

console.log(calculerSurface(5));     // 5 (5 × 1)
console.log(calculerSurface(5, 3));  // 15 (5 × 3)

// Fonction avec plusieurs paramètres
function presenter(nom, age, ville = "Paris") {
    return `Je suis ${nom}, j'ai ${age} ans et j'habite à ${ville}.`;
}

console.log(presenter("Bob", 25));           // Utilise Paris par défaut
console.log(presenter("Alice", 30, "Lyon")); // Utilise Lyon

Expression de fonction et fonctions fléchées

// Expression de fonction
const multiplier = function(a, b) {
    return a * b;
};

// Fonction fléchée (syntaxe moderne)
const additionner = (a, b) => {
    return a + b;
};

// Fonction fléchée courte (pour une seule expression)
const carre = x => x * x;
const salutation = nom => `Salut ${nom} !`;

console.log(multiplier(3, 4));   // 12
console.log(additionner(5, 7));  // 12
console.log(carre(6));           // 36
console.log(salutation("Marie")); // "Salut Marie !"

Portée (scope) des variables

let variableGlobale = "Je suis globale";

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

exemplePortee();
// console.log(variableLocale);   // ❌ Erreur ! Pas accessible ici

Exercices pratiques

1. Calculatrice

function calculatrice(operation, a, b) {
    switch (operation) {
        case '+':
            return a + b;
        case '-':
            return a - b;
        case '*':
            return a * b;
        case '/':
            if (b === 0) {
                return "Erreur: division par zéro";
            }
            return a / b;
        default:
            return "Opération non reconnue";
    }
}

console.log(calculatrice('+', 5, 3)); // 8
console.log(calculatrice('/', 10, 0)); // "Erreur: division par zéro"

2. Validateur de mot de passe

function validerMotDePasse(motDePasse) {
    const criteres = {
        longueur: motDePasse.length >= 8,
        majuscule: /[A-Z]/.test(motDePasse),
        minuscule: /[a-z]/.test(motDePasse),
        chiffre: /\d/.test(motDePasse),
        special: /[!@#$%^&*(),.?":{}|<>]/.test(motDePasse)
    };
    
    const valide = Object.values(criteres).every(Boolean);
    
    if (valide) {
        return "Mot de passe valide ✅";
    } else {
        const manquants = Object.entries(criteres)
            .filter(([_, valeur]) => !valeur)
            .map(([critere]) => critere);
        return `Critères manquants: ${manquants.join(', ')}`;
    }
}

console.log(validerMotDePasse("MonMotDePasse123!")); // "Mot de passe valide ✅"
console.log(validerMotDePasse("faible"));           // Liste les critères manquants

Objets

Création et utilisation

// Création d'un objet
const personne = {
    nom: "Alice",
    age: 30,
    ville: "Paris",
    estEtudiante: false,
    
    // Méthode
    sePresenter: function() {
        return `Je m'appelle ${this.nom} et j'ai ${this.age} ans.`;
    }
};

// Accès aux propriétés
console.log(personne.nom);        // "Alice"
console.log(personne["age"]);     // 30
console.log(personne.sePresenter()); // "Je m'appelle Alice et j'ai 30 ans."

// Modification
personne.age = 31;
personne["ville"] = "Lyon";
personne.profession = "Développeuse"; // Ajout d'une nouvelle propriété

Méthodes avec this

const compteBancaire = {
    titulaire: "Bob Martin",
    solde: 1000,
    
    deposer: function(montant) {
        if (montant > 0) {
            this.solde += montant;
            console.log(`Dépôt de ${montant}€. Nouveau solde: ${this.solde}€`);
        } else {
            console.log("Montant invalide");
        }
    },
    
    retirer: function(montant) {
        if (montant > 0 && montant <= this.solde) {
            this.solde -= montant;
            console.log(`Retrait de ${montant}€. Nouveau solde: ${this.solde}€`);
        } else {
            console.log("Retrait impossible");
        }
    },
    
    afficherSolde: function() {
        console.log(`Solde de ${this.titulaire}: ${this.solde}€`);
    }
};

compteBancaire.deposer(500);     // "Dépôt de 500€. Nouveau solde: 1500€"
compteBancaire.retirer(200);     // "Retrait de 200€. Nouveau solde: 1300€"
compteBancaire.afficherSolde();  // "Solde de Bob Martin: 1300€"

Objets et tableaux combinés

const etudiants = [
    {
        nom: "Alice",
        age: 20,
        notes: [15, 17, 14, 16]
    },
    {
        nom: "Bob", 
        age: 22,
        notes: [12, 14, 16, 13]
    },
    {
        nom: "Charlie",
        age: 19,
        notes: [18, 19, 17, 20]
    }
];

// Calculer la moyenne d'un étudiant
function calculerMoyenne(etudiant) {
    const somme = etudiant.notes.reduce((total, note) => total + note, 0);
    return somme / etudiant.notes.length;
}

// Afficher les résultats
etudiants.forEach(etudiant => {
    const moyenne = calculerMoyenne(etudiant);
    console.log(`${etudiant.nom}: ${moyenne.toFixed(1)}/20`);
});

Destructuring (déstructuration)

const produit = {
    nom: "Smartphone",
    prix: 599,
    marque: "TechCorp",
    enStock: true
};

// Ancienne méthode
// const nom = produit.nom;
// const prix = produit.prix;

// Nouvelle méthode (destructuring)
const { nom, prix, marque } = produit;
console.log(`${nom} de ${marque}: ${prix}€`);

// Avec renommage
const { nom: nomProduit, prix: prixProduit } = produit;
console.log(`Produit: ${nomProduit}, Prix: ${prixProduit}€`);

DOM et événements

Qu'est-ce que le DOM ?

Le DOM (Document Object Model) est la représentation en mémoire de la structure HTML de votre page. JavaScript peut l'utiliser pour modifier dynamiquement le contenu.

Sélection d'éléments

// Par ID
const titre = document.getElementById('monTitre');

// Par classe
const elements = document.getElementsByClassName('maClasse');
const premiers = document.querySelector('.maClasse'); // Premier élément seulement

// Par balise
const paragraphes = document.getElementsByTagName('p');
const premierP = document.querySelector('p');

// Sélecteurs CSS avancés
const bouton = document.querySelector('#monBouton');
const liens = document.querySelectorAll('a[href^="https"]'); // Liens externes

Manipulation du contenu

// HTML de base
// <h1 id="titre">Ancien titre</h1>
// <p id="description">Ancienne description</p>

const titre = document.getElementById('titre');
const description = document.getElementById('description');

// Modifier le texte
titre.textContent = "Nouveau titre";
titre.innerText = "Titre avec innerText";

// Modifier le HTML (attention aux risques de sécurité)
description.innerHTML = "<strong>Description</strong> en <em>gras et italique</em>";

// Plus sûr : créer des éléments
const strong = document.createElement('strong');
strong.textContent = "Description importante";
description.appendChild(strong);

Manipulation des styles et classes

const element = document.querySelector('.monElement');

// Styles directs
element.style.color = "red";
element.style.backgroundColor = "yellow";
element.style.fontSize = "18px";

// Classes CSS (recommandé)
element.classList.add('active');
element.classList.remove('hidden');
element.classList.toggle('highlight'); // Ajoute ou supprime selon présence
element.classList.contains('active'); // true/false

Création et suppression d'éléments

// Créer un nouvel élément
const nouvelleDiv = document.createElement('div');
nouvelleDiv.textContent = "Je suis une nouvelle div";
nouvelleDiv.classList.add('nouvelle');

// L'ajouter à la page
const conteneur = document.getElementById('conteneur');
conteneur.appendChild(nouvelleDiv);

// Supprimer un élément
const elementASupprimer = document.querySelector('.aSupprimer');
if (elementASupprimer) {
    elementASupprimer.remove(); // Méthode moderne
    // ou elementASupprimer.parentNode.removeChild(elementASupprimer); // Ancienne méthode
}

Événements

const bouton = document.getElementById('monBouton');
const input = document.getElementById('monInput');

// Événement de clic
bouton.addEventListener('click', function() {
    console.log('Bouton cliqué !');
});

// Avec une fonction fléchée
bouton.addEventListener('click', () => {
    alert('Hello !');
});

// Événements sur les champs de saisie
input.addEventListener('input', function(event) {
    console.log('Texte tapé:', event.target.value);
});

// Événement de soumission de formulaire
const formulaire = document.getElementById('monFormulaire');
formulaire.addEventListener('submit', function(event) {
    event.preventDefault(); // Empêche l'envoi par défaut
    console.log('Formulaire soumis');
});

L'objet event

document.addEventListener('click', function(event) {
    console.log('Élément cliqué:', event.target);
    console.log('Coordonnées:', event.clientX, event.clientY);
    console.log('Type d\'événement:', event.type);
});

// Empêcher la propagation
document.querySelector('.parent').addEventListener('click', function() {
    console.log('Parent cliqué');
});

document.querySelector('.enfant').addEventListener('click', function(event) {
    console.log('Enfant cliqué');
    event.stopPropagation(); // N'exécute pas le gestionnaire du parent
});

Projets pratiques

Projet 1 : Todo List

<!DOCTYPE html>
<html>
<head>
    <title>Todo List</title>
    <style>
        .completed { text-decoration: line-through; opacity: 0.6; }
        .todo-item { margin: 10px 0; }
    </style>
</head>
<body>
    <h1>Ma Todo List</h1>
    
    <div>
        <input type="text" id="nouvelleT ache" placeholder="Nouvelle tâche...">
        <button id="ajouterBtn">Ajouter</button>
    </div>
    
    <ul id="listeTaches"></ul>

    <script>
        const input = document.getElementById('nouvelleTache');
        const btnAjouter = document.getElementById('ajouterBtn');
        const liste = document.getElementById('listeTaches');

        function ajouterTache() {
            const texte = input.value.trim();
            
            if (texte === '') {
                alert('Veuillez entrer une tâche');
                return;
            }

            // Créer les éléments
            const li = document.createElement('li');
            li.className = 'todo-item';
            
            const span = document.createElement('span');
            span.textContent = texte;
            
            const btnToggle = document.createElement('button');
            btnToggle.textContent = '✓';
            btnToggle.addEventListener('click', () => {
                li.classList.toggle('completed');
            });
            
            const btnSupprimer = document.createElement('button');
            btnSupprimer.textContent = '✗';
            btnSupprimer.addEventListener('click', () => {
                li.remove();
            });
            
            // Assembler les éléments
            li.appendChild(span);
            li.appendChild(btnToggle);
            li.appendChild(btnSupprimer);
            liste.appendChild(li);
            
            // Vider le champ
            input.value = '';
        }

        // Événements
        btnAjouter.addEventListener('click', ajouterTache);
        input.addEventListener('keypress', (e) => {
            if (e.key === 'Enter') {
                ajouterTache();
            }
        });
    </script>
</body>
</html>

Projet 2 : Calculatrice

<!DOCTYPE html>
<html>
<head>
    <title>Calculatrice</title>
    <style>
        .calculatrice {
            max-width: 300px;
            margin: 50px auto;
            padding: 20px;
            border: 2px solid #333;
            border-radius: 10px;
            background-color: #f9f9f9;
        }
        
        .ecran {
            width: 100%;
            height: 60px;
            font-size: 24px;
            text-align: right;
            padding: 10px;
            margin-bottom: 15px;
            border: 1px solid #ccc;
            background-color: white;
        }
        
        .boutons {
            display: grid;
            grid-template-columns: repeat(4, 1fr);
            gap: 10px;
        }
        
        button {
            height: 50px;
            font-size: 18px;
            border: 1px solid #ccc;
            background-color: #e0e0e0;
            cursor: pointer;
            border-radius: 5px;
        }
        
        button:hover {
            background-color: #d0d0d0;
        }
        
        .operateur {
            background-color: #ff9500;
            color: white;
        }
        
        .operateur:hover {
            background-color: #e6890a;
        }
        
        .egal {
            background-color: #ff9500;
            color: white;
        }
        
        .effacer {
            background-color: #a6a6a6;
            color: white;
        }
    </style>
</head>
<body>
    <div class="calculatrice">
        <input type="text" class="ecran" id="ecran" readonly>
        
        <div class="boutons">
            <button class="effacer" onclick="effacer()">C</button>
            <button class="effacer" onclick="effacerDernier()">←</button>
            <button class="operateur" onclick="ajouterOperateur('/')">/</button>
            <button class="operateur" onclick="ajouterOperateur('*')">×</button>
            
            <button onclick="ajouterNombre('7')">7</button>
            <button onclick="ajouterNombre('8')">8</button>
            <button onclick="ajouterNombre('9')">9</button>
            <button class="operateur" onclick="ajouterOperateur('-')">-</button>
            
            <button onclick="ajouterNombre('4')">4</button>
            <button onclick="ajouterNombre('5')">5</button>
            <button onclick="ajouterNombre('6')">6</button>
            <button class="operateur" onclick="ajouterOperateur('+')">+</button>
            
            <button onclick="ajouterNombre('1')">1</button>
            <button onclick="ajouterNombre('2')">2</button>
            <button onclick="ajouterNombre('3')">3</button>
            <button class="egal" onclick="calculer()" rowspan="2">=</button>
            
            <button onclick="ajouterNombre('0')" style="grid-column: span 2;">0</button>
            <button onclick="ajouterNombre('.')">.</button>
        </div>
    </div>

    <script>
        let ecran = document.getElementById('ecran');
        let operateurPrecedent = '';
        let operande1 = '';
        let operande2 = '';
        let operateurActuel = '';

        function ajouterNombre(nombre) {
            if (ecran.value === '0' || ecran.value === 'Erreur') {
                ecran.value = nombre;
            } else {
                ecran.value += nombre;
            }
        }

        function ajouterOperateur(operateur) {
            if (operande1 === '') {
                operande1 = ecran.value;
            } else if (operateurActuel !== '' && ecran.value !== operande1) {
                operande2 = ecran.value;
                const resultat = effectuerCalcul();
                ecran.value = resultat;
                operande1 = resultat;
            }
            
            operateurActuel = operateur;
            ecran.value = operande1;
        }

        function calculer() {
            if (operande1 !== '' && operateurActuel !== '') {
                operande2 = ecran.value;
                const resultat = effectuerCalcul();
                ecran.value = resultat;
                operande1 = resultat.toString();
                operande2 = '';
                operateurActuel = '';
            }
        }

        function effectuerCalcul() {
            const a = parseFloat(operande1);
            const b = parseFloat(operande2);
            
            switch (operateurActuel) {
                case '+':
                    return a + b;
                case '-':
                    return a - b;
                case '*':
                    return a * b;
                case '/':
                    if (b === 0) {
                        return 'Erreur';
                    }
                    return a / b;
                default:
                    return b;
            }
        }

        function effacer() {
            ecran.value = '0';
            operande1 = '';
            operande2 = '';
            operateurActuel = '';
        }

        function effacerDernier() {
            if (ecran.value.length > 1) {
                ecran.value = ecran.value.slice(0, -1);
            } else {
                ecran.value = '0';
            }
        }

        // Support du clavier
        document.addEventListener('keydown', function(event) {
            const touche = event.key;
            
            if ('0123456789.'.includes(touche)) {
                ajouterNombre(touche);
            } else if ('+-*/'.includes(touche)) {
                ajouterOperateur(touche);
            } else if (touche === 'Enter' || touche === '=') {
                calculer();
            } else if (touche === 'Escape' || touche === 'c' || touche === 'C') {
                effacer();
            } else if (touche === 'Backspace') {
                effacerDernier();
            }
        });
    </script>
</body>
</html>

Projet 3 : Jeu de devinette de nombre

class JeuDevinette {
    constructor() {
        this.nombreSecret = this.genererNombreAleatoire(1, 100);
        this.tentatives = 0;
        this.maxTentatives = 7;
        this.fini = false;
        this.historique = [];
    }
    
    genererNombreAleatoire(min, max) {
        return Math.floor(Math.random() * (max - min + 1)) + min;
    }
    
    deviner(nombre) {
        if (this.fini) {
            return "Le jeu est terminé. Commencez une nouvelle partie.";
        }
        
        this.tentatives++;
        this.historique.push(nombre);
        
        if (nombre === this.nombreSecret) {
            this.fini = true;
            return `🎉 Félicitations ! Vous avez trouvé ${this.nombreSecret} en ${this.tentatives} tentative(s) !`;
        }
        
        if (this.tentatives >= this.maxTentatives) {
            this.fini = true;
            return `😔 Perdu ! Le nombre était ${this.nombreSecret}. Tentatives: ${this.historique.join(', ')}`;
        }
        
        const indication = nombre < this.nombreSecret ? "plus grand" : "plus petit";
        const tentativesRestantes = this.maxTentatives - this.tentatives;
        
        return `Le nombre est ${indication} que ${nombre}. Il vous reste ${tentativesRestantes} tentative(s).`;
    }
    
    nouvellePartie() {
        this.nombreSecret = this.genererNombreAleatoire(1, 100);
        this.tentatives = 0;
        this.fini = false;
        this.historique = [];
        return "Nouvelle partie commencée ! Devinez un nombre entre 1 et 100.";
    }
    
    obtenirStatistiques() {
        return {
            tentatives: this.tentatives,
            tentativesRestantes: this.maxTentatives - this.tentatives,
            historique: this.historique.slice(),
            fini: this.fini
        };
    }
}

// Interface utilisateur
const jeu = new JeuDevinette();

function jouer() {
    const input = document.getElementById('nombreInput');
    const resultat = document.getElementById('resultat');
    const stats = document.getElementById('statistiques');
    
    const nombre = parseInt(input.value);
    
    if (isNaN(nombre) || nombre < 1 || nombre > 100) {
        resultat.textContent = "Veuillez entrer un nombre valide entre 1 et 100.";
        return;
    }
    
    const reponse = jeu.deviner(nombre);
    resultat.textContent = reponse;
    
    const statistiques = jeu.obtenirStatistiques();
    stats.innerHTML = `
        <p>Tentatives: ${statistiques.tentatives}/${jeu.maxTentatives}</p>
        <p>Historique: ${statistiques.historique.join(', ')}</p>
    `;
    
    if (statistiques.fini) {
        document.getElementById('devinerBtn').disabled = true;
        document.getElementById('nouvellePartieBtn').style.display = 'inline-block';
    }
    
    input.value = '';
}

function nouvellePartie() {
    const reponse = jeu.nouvellePartie();
    document.getElementById('resultat').textContent = reponse;
    document.getElementById('statistiques').innerHTML = '';
    document.getElementById('devinerBtn').disabled = false;
    document.getElementById('nouvellePartieBtn').style.display = 'none';
}

Projet 4 : Gestionnaire de contact

class GestionnaireContacts {
    constructor() {
        this.contacts = this.chargerContacts();
        this.afficherContacts();
    }
    
    ajouterContact(nom, email, telephone) {
        // Validation
        if (!nom || !email || !telephone) {
            return "Tous les champs sont obligatoires.";
        }
        
        if (!this.validerEmail(email)) {
            return "Email invalide.";
        }
        
        if (this.contacts.find(c => c.email === email)) {
            return "Un contact avec cet email existe déjà.";
        }
        
        const contact = {
            id: Date.now(),
            nom: nom.trim(),
            email: email.trim().toLowerCase(),
            telephone: telephone.trim(),
            dateAjout: new Date().toLocaleDateString()
        };
        
        this.contacts.push(contact);
        this.sauvegarderContacts();
        this.afficherContacts();
        return "Contact ajouté avec succès !";
    }
    
    supprimerContact(id) {
        const index = this.contacts.findIndex(c => c.id === id);
        if (index > -1) {
            this.contacts.splice(index, 1);
            this.sauvegarderContacts();
            this.afficherContacts();
            return "Contact supprimé.";
        }
        return "Contact introuvable.";
    }
    
    rechercherContacts(terme) {
        if (!terme) return this.contacts;
        
        terme = terme.toLowerCase();
        return this.contacts.filter(contact =>
            contact.nom.toLowerCase().includes(terme) ||
            contact.email.toLowerCase().includes(terme) ||
            contact.telephone.includes(terme)
        );
    }
    
    validerEmail(email) {
        const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
        return regex.test(email);
    }
    
    sauvegarderContacts() {
        localStorage.setItem('contacts', JSON.stringify(this.contacts));
    }
    
    chargerContacts() {
        const contacts = localStorage.getItem('contacts');
        return contacts ? JSON.parse(contacts) : [];
    }
    
    afficherContacts(contactsAfficher = null) {
        const contacts = contactsAfficher || this.contacts;
        const conteneur = document.getElementById('listeContacts');
        
        if (contacts.length === 0) {
            conteneur.innerHTML = '<p>Aucun contact trouvé.</p>';
            return;
        }
        
        conteneur.innerHTML = contacts.map(contact => `
            <div class="contact" data-id="${contact.id}">
                <div class="contact-info">
                    <h3>${contact.nom}</h3>
                    <p>📧 ${contact.email}</p>
                    <p>📱 ${contact.telephone}</p>
                    <small>Ajouté le: ${contact.dateAjout}</small>
                </div>
                <button onclick="gestionnaire.supprimerContact(${contact.id})" class="btn-supprimer">
                    Supprimer
                </button>
            </div>
        `).join('');
    }
}

// Initialisation
const gestionnaire = new GestionnaireContacts();

// Fonctions de l'interface
function ajouterContact() {
    const nom = document.getElementById('nom').value;
    const email = document.getElementById('email').value;
    const telephone = document.getElementById('telephone').value;
    
    const resultat = gestionnaire.ajouterContact(nom, email, telephone);
    document.getElementById('message').textContent = resultat;
    
    // Vider le formulaire si succès
    if (resultat.includes('succès')) {
        document.getElementById('formulaireContact').reset();
    }
}

function rechercherContacts() {
    const terme = document.getElementById('recherche').value;
    const resultats = gestionnaire.rechercherContacts(terme);
    gestionnaire.afficherContacts(resultats);
}

Gestion des erreurs et débogage

Try...catch

function diviserSecurise(a, b) {
    try {
        if (typeof a !== 'number' || typeof b !== 'number') {
            throw new Error('Les arguments doivent être des nombres');
        }
        
        if (b === 0) {
            throw new Error('Division par zéro impossible');
        }
        
        return a / b;
    } catch (erreur) {
        console.error('Erreur:', erreur.message);
        return null;
    } finally {
        console.log('Opération de division terminée');
    }
}

console.log(diviserSecurise(10, 2));  // 5
console.log(diviserSecurise(10, 0));  // null, avec message d'erreur
console.log(diviserSecurise("a", 2)); // null, avec message d'erreur

Techniques de débogage

// 1. Console.log stratégique
function calculerMoyenne(notes) {
    console.log('Entrée de la fonction:', notes);
    
    if (!Array.isArray(notes)) {
        console.error('Erreur: notes doit être un tableau');
        return null;
    }
    
    const somme = notes.reduce((total, note) => {
        console.log(`Ajout de ${note} au total ${total}`);
        return total + note;
    }, 0);
    
    console.log('Somme calculée:', somme);
    const moyenne = somme / notes.length;
    console.log('Moyenne finale:', moyenne);
    
    return moyenne;
}

// 2. Assertions simples
function verifierAge(age) {
    console.assert(typeof age === 'number', 'Age doit être un nombre');
    console.assert(age >= 0, 'Age ne peut pas être négatif');
    console.assert(age <= 150, 'Age ne peut pas dépasser 150 ans');
    
    return age >= 18 ? 'majeur' : 'mineur';
}

// 3. Debugger (points d'arrêt)
function fonctionComplexe(data) {
    debugger; // Le navigateur s'arrêtera ici
    
    const resultat = data.map(item => {
        debugger; // Et ici pour chaque itération
        return item * 2;
    });
    
    return resultat;
}

Bonnes pratiques et astuces

1. Nommage et structure

// ✅ Bonnes pratiques
const TAUX_TVA = 0.20;           // Constante en majuscules
const utilisateurConnecte = {};   // CamelCase pour variables
const calculerPrixTTC = () => {}; // Fonction descriptive

// ❌ À éviter
const t = 0.20;                  // Nom non descriptif
const user_connected = {};       // Snake_case (pas la convention JS)
const calc = () => {};           // Nom trop court

2. Structure du code

// ✅ Bien structuré
function validerFormulaire(donnees) {
    // Validation d'entrée
    if (!donnees) {
        return { valide: false, erreur: 'Données manquantes' };
    }
    
    // Logique métier
    const erreurs = [];
    
    if (!donnees.email || !validerEmail(donnees.email)) {
        erreurs.push('Email invalide');
    }
    
    if (!donnees.nom || donnees.nom.length < 2) {
        erreurs.push('Nom trop court');
    }
    
    // Retour structuré
    return {
        valide: erreurs.length === 0,
        erreurs: erreurs
    };
}

function validerEmail(email) {
    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

3. Gestion des cas d'erreur

function obtenirUtilisateur(id) {
    // Vérifications d'entrée
    if (!id) {
        throw new Error('ID utilisateur requis');
    }
    
    if (typeof id !== 'number' || id <= 0) {
        throw new Error('ID utilisateur invalide');
    }
    
    // Simulation d'accès base de données
    const utilisateurs = [
        { id: 1, nom: 'Alice' },
        { id: 2, nom: 'Bob' }
    ];
    
    const utilisateur = utilisateurs.find(u => u.id === id);
    
    if (!utilisateur) {
        throw new Error(`Utilisateur ${id} introuvable`);
    }
    
    return utilisateur;
}

// Utilisation avec gestion d'erreur
try {
    const user = obtenirUtilisateur(1);
    console.log('Utilisateur trouvé:', user);
} catch (error) {
    console.error('Erreur:', error.message);
}

4. Performance et optimisation

// ✅ Optimisé pour les gros tableaux
const grandsNombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

// Utiliser les méthodes de tableau appropriées
const pairs = grandsNombres.filter(n => n % 2 === 0);
const doubles = grandsNombres.map(n => n * 2);
const somme = grandsNombres.reduce((total, n) => total + n, 0);

// ❌ Éviter les boucles inutiles
// for (let i = 0; i < grandsNombres.length; i++) {
//     // Logique répétitive...
// }

// ✅ Mettre en cache les sélections DOM coûteuses
const elements = document.querySelectorAll('.item');
elements.forEach(element => {
    element.addEventListener('click', handleClick);
});

// ❌ Éviter les sélections répétées
// document.querySelectorAll('.item').forEach(...)
// document.querySelectorAll('.item').forEach(...) // Recherche DOM répétée

Conclusion et prochaines étapes

Ce que vous avez appris

Pour aller plus loin

  1. ES6+ Features: Destructuring, modules, async/await
  2. Frameworks: React, Vue.js, Angular
  3. Node.js: JavaScript côté serveur
  4. APIs: Fetch, REST, GraphQL
  5. Outils de développement: npm, webpack, git

Ressources recommandées

Exercice final : Mini-projet libre

Créez une application de votre choix qui combine :

Idées de projets :

Bon codage ! 🚀