Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
JavaScript

TP 10 : Écrire un script modulaire avec des fonctions

Écrire un script modulaire avec des fonctions. Dans cette leçon du cours JavaScript, vous apprendrez à : découper un programme en petites fonctions qui font chacune une seule chose ; écrire des foncti...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Écrire un script modulaire avec des fonctions. Dans cette leçon du cours JavaScript, vous apprendrez à : découper un programme en petites fonctions qui font chacune une seule chose ; écrire des fonctions pures, testables, avec paramètres par défaut et paramètre rest ; utiliser des callbacks, une fonction qui renvoie une fonction et une closure ; faire passer une batterie de tests automatiques au vert.

Chapitre 10 — Les fonctions en JavaScript · TP 10 : Écrire un script modulaire avec des fonctions

🎯 Objectifs de la leçon
• découper un programme en petites fonctions qui font chacune une seule chose ;
• écrire des fonctions pures, testables, avec paramètres par défaut et paramètre rest ;
• utiliser des callbacks, une fonction qui renvoie une fonction et une closure ;
• faire passer une batterie de tests automatiques au vert.

Présentation

Vous allez écrire la « boîte à outils » qui calcule et affiche le bulletin de notes d'un groupe : moyennes pondérées, mentions, matricules, statistiques et tri. Le projet est découpé en trois fichiers JavaScript :

  • notes.js: vos 9 fonctions, vides au départ ;
  • tests.js (fourni) : 21 tests automatiques qui appellent vos fonctions et affichent ✓ ou ✗ en bas de la page ;
  • app.js (fourni) : construit le tableau du bulletin en utilisant uniquement vos fonctions.

Votre objectif : obtenir 21 / 21. À chaque fonction terminée, rechargez la page : les tests correspondants passent au vert et le bulletin se remplit. Les questions vous guident ; aucune solution n'est donnée.

Les tests au départ : 0 sur 21
Figure 1 — Au départ, tous les tests échouent : chaque ligne rouge indique la valeur attendue et la valeur obtenue.

Le bulletin terminé et les tests au vert
Figure 2 — L'objectif : le bulletin complet et 21 tests sur 21.

Fichiers de départ

⬇ Télécharger les fichiers de départ du TP (tp10-depart.zip)

Téléchargez le dossier de départ (bouton ci-dessous). Lisez tests.js: chaque test est un exemple précis de ce que doit faire une fonction. Ne modifiez ni tests.js, ni app.js, ni le HTML.

notes.js (à compléter)
// =====================================================================
// TP 10 — Bulletin de notes : VOS FONCTIONS
// Chaque fonction fait UNE seule chose. Complétez-les une par une :
// la page de tests (en bas de index.html) passe au vert au fur et à mesure.
// Ne modifiez ni tests.js ni app.js.
// =====================================================================

// 1. Arrondir un nombre à n décimales (2 par défaut) — renvoie un NOMBRE
function arrondir(valeur, decimales = 2) {
  // À COMPLÉTER
}

// 2. Une note est valide si c'est un nombre (pas NaN) compris entre 0 et 20
function estValide(note) {
  // À COMPLÉTER
}

// 3. Moyenne simple d'un nombre quelconque de notes ; ignore les notes non valides ;
//    renvoie null s'il n'y a aucune note valide
function moyenne(...notes) {
  // À COMPLÉTER
}

// 4. Moyenne pondérée d'un tableau [{ note, coef }, …], arrondie à 2 décimales ;
//    ignore les notes non valides ; null si aucune note valide
function moyennePonderee(resultats) {
  // À COMPLÉTER
}

// 5. Mention selon la moyenne : ≥ 16 « Très bien », ≥ 14 « Bien », ≥ 12 « Assez bien »,
//    ≥ 10 « Passable », sinon « Insuffisant » ; « — » si la moyenne vaut null
function mention(moy) {
  // À COMPLÉTER
}

// 6. Afficher une note à la française avec 2 décimales : 12.5 → "12,50" ; null → "—"
function formaterNote(note) {
  // À COMPLÉTER
}

// 7. Fabrique de matricules (closure) : creerGenerateur("STG")() → "STG-001", puis "STG-002"…
function creerGenerateur(prefixe, largeur = 3) {
  // À COMPLÉTER
}

// 8. Statistiques d'un tableau de nombres (null ignorés) : { min, max, moyenne }
//    ou null si le tableau ne contient aucun nombre
function statistiques(valeurs) {
  // À COMPLÉTER
}

// 9. Fonction d'ordre supérieur : renvoie une fonction de comparaison pour sort
//    comparerPar("nom") trie par ordre alphabétique (français), comparerPar("moyenne")
//    trie par moyenne DÉCROISSANTE (les null à la fin)
function comparerPar(critere) {
  // À COMPLÉTER
}
tests.js (fourni, à lire)
// =====================================================================
// Tests automatiques (fourni — ne pas modifier)
// =====================================================================
(function () {
  const liste = document.querySelector("#tests");
  let reussis = 0;
  let total = 0;

  function test(description, calcul, attendu) {
    total++;
    const li = document.createElement("li");
    let obtenu;
    try {
      obtenu = calcul();
    } catch (e) {
      obtenu = "Erreur : " + e.message;
    }
    const ok = JSON.stringify(obtenu) === JSON.stringify(attendu);
    if (ok) reussis++;
    li.className = ok ? "ok" : "ko";
    li.textContent = (ok ? "✓ " : "✗ ") + description;
    if (!ok) {
      const detail = document.createElement("small");
      detail.textContent = `attendu ${JSON.stringify(attendu)}, obtenu ${JSON.stringify(obtenu)}`;
      li.append(detail);
    }
    liste.append(li);
  }

  test("arrondir(12.345) vaut 12.35", () => arrondir(12.345), 12.35);
  test("arrondir(12.3456, 1) vaut 12.3", () => arrondir(12.3456, 1), 12.3);
  test("arrondir(7) vaut 7", () => arrondir(7), 7);
  test("estValide(15) et estValide(0) valent true", () => [estValide(15), estValide(0)], [true, true]);
  test("estValide(21), estValide(-1), estValide(NaN), estValide(\"12\") valent false", () => [estValide(21), estValide(-1), estValide(NaN), estValide("12")], [false, false, false, false]);
  test("moyenne(12, 14, 16) vaut 14", () => moyenne(12, 14, 16), 14);
  test("moyenne(10, null, 30, 14) ignore les notes non valides et vaut 12", () => moyenne(10, null, 30, 14), 12);
  test("moyenne() vaut null", () => moyenne(), null);
  test("moyennePonderee : 10 (coef 2) et 16 (coef 3) donnent 13.6", () => moyennePonderee([{ note: 10, coef: 2 }, { note: 16, coef: 3 }]), 13.6);
  test("moyennePonderee ignore une note manquante", () => moyennePonderee([{ note: 12, coef: 2 }, { note: null, coef: 3 }, { note: 15, coef: 1 }]), 13);
  test("moyennePonderee([]) vaut null", () => moyennePonderee([]), null);
  test("mention(16), mention(15.99), mention(10), mention(9.99)", () => [mention(16), mention(15.99), mention(10), mention(9.99)], ["Très bien", "Bien", "Passable", "Insuffisant"]);
  test("mention(null) vaut \"—\"", () => mention(null), "—");
  test("formaterNote(12.5) vaut \"12,50\" et formaterNote(null) vaut \"—\"", () => [formaterNote(12.5), formaterNote(null)], ["12,50", "—"]);
  test("creerGenerateur(\"STG\") produit STG-001 puis STG-002", () => { const g = creerGenerateur("STG"); return [g(), g()]; }, ["STG-001", "STG-002"]);
  test("deux générateurs sont indépendants", () => { const a = creerGenerateur("A", 2); const b = creerGenerateur("B"); a(); a(); return [a(), b()]; }, ["A-03", "B-001"]);
  test("statistiques([12, null, 8, 16])", () => statistiques([12, null, 8, 16]), { min: 8, max: 16, moyenne: 12 });
  test("statistiques([]) vaut null", () => statistiques([]), null);
  test("comparerPar(\"nom\") trie Élodie entre Driss et Fatima", () => ["Fatima", "Élodie", "Driss"].map((nom) => ({ nom })).sort(comparerPar("nom")).map((s) => s.nom), ["Driss", "Élodie", "Fatima"]);
  test("comparerPar(\"moyenne\") trie par moyenne décroissante, null à la fin", () => [{ moyenne: 12 }, { moyenne: null }, { moyenne: 15 }].sort(comparerPar("moyenne")).map((s) => s.moyenne), [15, 12, null]);
  test("comparerPar ne modifie pas les objets (fonction pure)", () => { const a = [{ nom: "B" }, { nom: "A" }]; a.sort(comparerPar("nom")); return a.map((s) => Object.keys(s).length + s.nom); }, ["1A", "1B"]);

  const score = document.querySelector("#score");
  score.textContent = `${reussis} / ${total}`;
  score.classList.toggle("complet", reussis === total);
})();
app.js (fourni)
// =====================================================================
// Affichage du bulletin (fourni — ne pas modifier)
// Ce fichier n'utilise QUE vos fonctions de notes.js.
// =====================================================================
const STAGIAIRES = [
  { nom: "Salma Idrissi",   notes: { html: 14,   js: 15.5, anglais: 12 } },
  { nom: "Karim Benali",    notes: { html: 9,    js: 8.5,  anglais: 11 } },
  { nom: "Élodie Martin",   notes: { html: 17,   js: 18,   anglais: null } },
  { nom: "Amina Tazi",      notes: { html: 12.5, js: 11,   anglais: 14 } },
  { nom: "Yassine Alaoui",  notes: { html: null, js: null, anglais: null } },
  { nom: "Driss Ouazzani",  notes: { html: 10,   js: 9.75, anglais: 9 } },
];
const COEFS = { html: 2, js: 3, anglais: 1 };

function preparer() {
  const prochainMatricule = creerGenerateur("DEV101");
  return STAGIAIRES.map((s) => {
    const resultats = Object.entries(s.notes).map(([matiere, note]) => ({ note, coef: COEFS[matiere] }));
    const moy = moyennePonderee(resultats);
    return { matricule: prochainMatricule ? prochainMatricule() : "?", ...s, moyenne: moy, mention: mention(moy) };
  });
}

function afficher() {
  let lignes = preparer();
  if (document.querySelector("#admisSeulement").checked) lignes = lignes.filter((s) => s.moyenne !== null && s.moyenne >= 10);
  const comparateur = comparerPar(document.querySelector("#tri").value);
  if (typeof comparateur === "function") lignes.sort(comparateur);

  const corps = document.querySelector("#bulletin");
  corps.replaceChildren();
  for (const s of lignes) {
    const tr = document.createElement("tr");
    if (s.moyenne !== null && s.moyenne !== undefined) tr.className = s.moyenne >= 10 ? "admis" : "refuse";
    const cellules = [s.matricule, s.nom, formaterNote(s.notes.html), formaterNote(s.notes.js), formaterNote(s.notes.anglais), formaterNote(s.moyenne), s.mention];
    cellules.forEach((valeur, i) => {
      const td = document.createElement("td");
      td.textContent = valeur ?? "?";
      if (i === 5) td.classList.add("moyenne");
      if (valeur === "—") td.classList.add("vide");
      tr.append(td);
    });
    corps.append(tr);
  }

  const st = statistiques(preparer().map((s) => s.moyenne));
  document.querySelector("#stats").textContent = st
    ? `Moyenne du groupe : ${formaterNote(st.moyenne)} — meilleure : ${formaterNote(st.max)} — plus faible : ${formaterNote(st.min)}`
    : "Statistiques indisponibles (complétez la fonction statistiques).";
}

document.querySelector("#tri").addEventListener("change", afficher);
document.querySelector("#admisSeulement").addEventListener("change", afficher);
afficher();
index.html (fourni)
<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>TP 10 — Bulletin de notes</title>
  <link rel="stylesheet" href="style.css">
</head>
<body>
  <main>
    <h1>Bulletin du groupe DEV101</h1>

    <section class="carte">
      <h2>Bulletin</h2>
      <div class="outils">
        <label>Trier par
          <select id="tri">
            <option value="nom">Nom</option>
            <option value="moyenne">Moyenne</option>
          </select>
        </label>
        <label><input type="checkbox" id="admisSeulement"> Admis seulement</label>
      </div>
      <table>
        <thead>
          <tr><th>Matricule</th><th>Stagiaire</th><th>HTML/CSS (coef 2)</th><th>JavaScript (coef 3)</th><th>Anglais (coef 1)</th><th>Moyenne</th><th>Mention</th></tr>
        </thead>
        <tbody id="bulletin"></tbody>
      </table>
      <p id="stats" class="stats"></p>
    </section>

    <section class="carte">
      <h2>Tests de vos fonctions <span id="score" class="score"></span></h2>
      <ol id="tests" class="tests"></ol>
    </section>
  </main>

  <!-- L'ordre compte : vos fonctions d'abord, puis les fichiers qui les utilisent -->
  <script src="notes.js"></script>
  <script src="tests.js"></script>
  <script src="app.js"></script>
</body>
</html>

🛠 TP · Partie 1 — Les fonctions de base

Mission : Complétez arrondir, estValide et moyenne (tests 1 à 8).

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. arrondir(valeur, decimales = 2) doit renvoyer un nombre. Pourquoi toFixed ne convient-il pas ici ? Quelle opération utilisez-vous avec Math.round?
  2. estValide doit refuser "12" (une chaîne) et NaN. Quels tests enchaînez-vous, et dans quel ordre ? Pourquoi typeof NaN ne suffit-il pas ?
  3. moyenne(...notes) accepte un nombre quelconque d'arguments. Comment éliminez-vous les notes non valides en réutilisant estValide comme callback ?
  4. Que doit renvoyer moyenne()? Pourquoi null est-il plus juste que 0 pour un stagiaire sans aucune note ?

Je vérifie / je rends :

  • ☐ Tests 1 à 8 au vert.

🛠 TP · Partie 2 — Moyenne pondérée et mention

Mission : Complétez moyennePonderee et mention (tests 9 à 13).

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. Chaque résultat est un objet { note, coef }. Écrivez la formule de la moyenne pondérée sur papier, puis traduisez-la avec filter et reduce.
  2. Une note manquante (null) doit être ignorée avec son coefficient. Pourquoi ? Vérifiez votre calcul sur le test 10 à la main.
  3. Quelle fonction déjà écrite utilisez-vous pour arrondir le résultat ?
  4. Pour mention, dans quel ordre testez-vous les seuils ? Que se passerait-il si vous testiez « ≥ 10 » en premier ?

Je vérifie / je rends :

  • ☐ Tests 9 à 13 au vert ; la colonne Moyenne du bulletin se remplit.

🛠 TP · Partie 3 — Affichage et matricules

Mission : Complétez formaterNote et creerGenerateur (tests 14 à 16).

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. formaterNote(12.5) doit donner « 12,50 ». Quelle méthode des nombres et quelle méthode des chaînes combinez-vous ? (Vous pourriez aussi utiliser Intl.NumberFormat, chapitre 11.)
  2. creerGenerateur("STG") doit renvoyer une fonction. Où déclarez-vous le compteur pour qu'il soit conservé entre deux appels, mais différent pour chaque générateur ? Comment s'appelle ce mécanisme ?
  3. Comment obtenez-vous « 001 » à partir du nombre 1 ? À quoi sert le paramètre largeur?
  4. Dans app.js, combien de fois creerGenerateur est-il appelé à chaque affichage ? Pourquoi les matricules ne continuent-ils pas à 007, 008… quand on change le tri ?

Je vérifie / je rends :

  • ☐ Tests 14 à 16 au vert ; les matricules DEV101-001… apparaissent.

🛠 TP · Partie 4 — Statistiques et tri

Mission : Complétez statistiques et comparerPar (tests 17 à 21).

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. Dans statistiques, comment obtenez-vous le minimum et le maximum d'un tableau sans boucle ? Que se passerait-il avec un tableau vide si vous ne le traitiez pas à part ?
  2. comparerPar(critere) renvoie une fonction de comparaison. Pour les noms, pourquoi a.nom < b.nom place-t-il mal « Élodie » ? Quel objet du chapitre 11 trie correctement les mots accentués ?
  3. Pour les moyennes, le tri est décroissant et les null vont à la fin. Écrivez d'abord sur papier ce que doit renvoyer la fonction pour les cas (15, 12), (null, 12) et (12, null).
  4. Le test 21 vérifie que votre fonction de comparaison ne modifie pas les objets. Pourquoi est-ce important pour une fonction passée à sort?

Je vérifie / je rends :

  • ☐ 21 / 21 ; le tri et le filtre « Admis seulement » fonctionnent.

🛠 TP · Partie 5 — Réflexion et compte rendu

Mission : Analysez la structure du projet.

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. Quelles fonctions de notes.js sont pures (même entrée, même sortie, rien modifié à l'extérieur) ? Laquelle ne l'est pas, et pourquoi est-ce voulu ?
  2. Listez les fonctions qui reçoivent une fonction en argument et celles qui en renvoient une.
  3. Pourquoi l'ordre des balises <script> dans index.html est-il important ? Que se passe-t-il si app.js est chargé avant notes.js?
  4. Toutes les fonctions sont globales. Quel risque cela présente-t-il dans une grande page ? Quelle solution verrez-vous au chapitre 17 ?

Je vérifie / je rends :

  • ☐ Un compte rendu d'une page répondant à ces questions.

🛠 TP · Partie 6 — Bonus

Mission : Allez plus loin.

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. Ajoutez une fonction rang(stagiaires) qui ajoute à chaque stagiaire son rang (1er, 2e, 2e ex aequo…), sans modifier le tableau reçu.
  2. Ajoutez vos propres tests dans un fichier mes-tests.js (même principe que tests.js) pour rang.
  3. Écrivez memoriser(f) et utilisez-la pour moyennePonderee. Pourquoi est-ce délicat avec un argument qui est un tableau ?

Je vérifie / je rends :

  • ☐ Les bonus réalisés, décrits dans le compte rendu.

Scénarios de recette

Le corrigé de l'enseignant réussit tous ces scénarios :

  1. La page de tests affiche 21 / 21 sur fond vert.
  2. Tri par nom : Amina, Driss, Élodie, Karim, Salma, Yassine (l'accent ne place pas Élodie à la fin).
  3. Les matricules vont de DEV101-001 (Salma) à DEV101-006 (Driss), quel que soit le tri.
  4. Moyennes : Salma 14,42 (Bien), Élodie 17,60 (Très bien, sans note d'anglais), Yassine « — » (aucune note).
  5. Tri par moyenne : Élodie en tête, Yassine à la fin.
  6. « Admis seulement » : 3 stagiaires.
  7. Ligne de statistiques : moyenne du groupe 12,56, meilleure 17,60, plus faible 9,08.
  8. Aucune erreur dans la console.

Grille d'évaluation indicative

CritèrePoints
Partie 1 — arrondir, estValide, moyenne (paramètres par défaut, rest, callback)4
Partie 2 — moyenne pondérée et mention4
Partie 3 — formatage et générateur (closure)3
Partie 4 — statistiques et comparateur (fonction qui renvoie une fonction)4
Partie 5 — compte rendu de réflexion3
Qualité du code (noms, fonctions courtes, pas de variable globale inutile)2
Total (bonus : jusqu'à +3)20

← Les closures (fermetures)

Cet article vous a-t-il aidé ?