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

Les callbacks et les fonctions d'ordre supérieur

Les callbacks et les fonctions d'ordre supérieur. Dans cette leçon du cours JavaScript, vous apprendrez à : comprendre ce qu'est un callback et une fonction d'ordre supérieur ; utiliser forEach, filte...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Les callbacks et les fonctions d'ordre supérieur. Dans cette leçon du cours JavaScript, vous apprendrez à : comprendre ce qu'est un callback et une fonction d'ordre supérieur ; utiliser forEach, filter, map, reduce, find, some, every et sort ; écrire ses propres fonctions qui reçoivent ou renvoient des fonctions ; enchaîner des traitements de façon lisible.

Chapitre 10 — Les fonctions en JavaScript · Les callbacks et les fonctions d'ordre supérieur

🎯 Objectifs de la leçon
• comprendre ce qu'est un callback et une fonction d'ordre supérieur ;
• utiliser forEach, filter, map, reduce, find, some, every et sort;
• écrire ses propres fonctions qui reçoivent ou renvoient des fonctions ;
• enchaîner des traitements de façon lisible.

1. Passer une fonction à une fonction

Puisqu'une fonction est une valeur, on peut la passer en argument. La fonction transmise s'appelle un callback (fonction de rappel) : l'autre fonction « rappellera » ce code au bon moment — pour chaque élément d'un tableau, après un délai, lors d'un clic… Une fonction qui reçoit ou renvoie une fonction est dite d'ordre supérieur. Vous en utilisez déjà : setTimeout, addEventListener, sort.

filter, map et reduce enchaînés
Figure 1 — Chaque méthode reçoit un callback et produit un nouveau résultat.

2. Les méthodes des tableaux

// 1. Un callback : une fonction passée en argument à une autre fonction
function repeter(fois, action) {
  for (let i = 1; i <= fois; i++) action(i);
}
repeter(3, (i) => console.log(`Tour ${i}`));

// 2. Les méthodes des tableaux sont des fonctions d'ordre supérieur
const stagiaires = [
  { nom: "Amina", note: 15.5, groupe: "DEV101" },
  { nom: "Karim", note: 9, groupe: "DEV102" },
  { nom: "Salma", note: 12, groupe: "DEV101" },
  { nom: "Yassine", note: 17, groupe: "DEV102" },
];
const admis = stagiaires.filter((s) => s.note >= 10);
const noms = admis.map((s) => s.nom.toUpperCase());
const total = stagiaires.reduce((somme, s) => somme + s.note, 0);
const premier = stagiaires.find((s) => s.note >= 16);
const classement = [...stagiaires].sort((a, b) => b.note - a.note).map((s) => `${s.nom} ${s.note}`);
console.log("Admis :", noms.join(", "));
console.log("Moyenne du groupe :", (total / stagiaires.length).toFixed(2));
console.log("Premier ≥ 16 :", premier.nom, "| Classement :", classement.join(" > "));
console.log("Tous ont une note ?", stagiaires.every((s) => typeof s.note === "number"), "| Un DEV102 admis ?", stagiaires.some((s) => s.groupe === "DEV102" && s.note >= 10));

// 3. Écrire sa propre fonction d'ordre supérieur
function compter(tableau, condition) {
  let n = 0;
  for (const element of tableau) if (condition(element)) n++;
  return n;
}
console.log("DEV101 :", compter(stagiaires, (s) => s.groupe === "DEV101"));

// 4. Une fonction qui RENVOIE une fonction
function plusGrandQue(seuil) {
  return (s) => s.note > seuil;
}
const excellents = stagiaires.filter(plusGrandQue(15));
console.log("Note > 15 :", excellents.map((s) => s.nom));

// 5. Composer des fonctions : enchaîner des traitements
const pipeline = (...etapes) => (valeur) => etapes.reduce((v, f) => f(v), valeur);
const nettoyer = pipeline((t) => t.trim(), (t) => t.toLowerCase(), (t) => t.replace(/\s+/g, "-"));
console.log("Identifiant :", nettoyer("  Programmation   en JavaScript "));

// 6. Piège : passer la fonction, pas son résultat
const direBonjour = () => "Bonjour";
console.log("typeof direBonjour   =", typeof direBonjour, "| typeof direBonjour() =", typeof direBonjour());

Résultat dans la console

Tour 1
Tour 2
Tour 3
Admis : AMINA, SALMA, YASSINE
Moyenne du groupe : 13.38
Premier ≥ 16 : Yassine | Classement : Yassine 17 > Amina 15.5 > Salma 12 > Karim 9
Tous ont une note ? true | Un DEV102 admis ? true
DEV101 : 2
Note > 15 : [ 'Amina', 'Yassine' ]
Identifiant : programmation-en-javascript
typeof direBonjour   = function | typeof direBonjour() = string
MéthodeLe callback reçoit…Renvoie
forEach(f)chaque élément (et son indice)rien : sert à agir (afficher, modifier la page)
filter(f)chaque élément ; doit renvoyer true/falseun nouveau tableau des éléments retenus
map(f)chaque élément ; renvoie sa transformationun nouveau tableau de même longueur
reduce(f, depart)l'accumulateur et l'élémentune seule valeur (somme, maximum, objet…)
find(f) / findIndex(f)chaque élément ; renvoie true pour celui cherchéle premier élément trouvé (ou undefined) / son indice
some(f) / every(f)chaque élémenttrue si au moins un / si tous vérifient la condition
sort(f)deux éléments a et b; négatif si a avant ble tableau trié (modifié sur place)

3. Écrire ses propres fonctions d'ordre supérieur

  • compter(tableau, condition) reçoit la condition sous forme de fonction : la même fonction compte n'importe quoi.
  • plusGrandQue(seuil) renvoie une fonction prête à être donnée à filter: on fabrique des critères à la demande.
  • pipeline(...etapes) compose plusieurs fonctions en une seule : chaque étape reçoit le résultat de la précédente.
⚠️ Attention
Passez la fonction elle-même : notes.map(doubler), pas notes.map(doubler()) (qui appellerait doubler une seule fois, sans argument, et passerait son résultat). Attention aussi à sort: sans fonction de comparaison, il trie comme du texte ([10, 9, 1].sort() donne [1, 10, 9]), et il modifie le tableau d'origine — copiez-le d'abord avec [...tableau] si besoin.
ℹ️ À retenir
• Callback : fonction passée en argument ; fonction d'ordre supérieur : reçoit ou renvoie une fonction.
• filter garde, map transforme, reduce résume, find cherche, some/every vérifient.
• sort((a, b) => a - b) pour des nombres ; il modifie le tableau.
• Une fonction qui renvoie une fonction fabrique des comportements sur mesure.

🛠 Activité 7 — Le catalogue de formations

Mission : À partir d'un tableau d'objets { titre, categorie, duree, prix } d'une dizaine de formations, répondez à chaque question par une seule chaîne de méthodes.

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

  1. Affichez les titres de toutes les formations avec forEach, puis obtenez le tableau des titres avec map. Quelle est la différence entre les deux ?
  2. Obtenez les formations de la catégorie « Web » de moins de 40 heures. Dans quel ordre enchaînez-vous filter et map pour ne garder que les titres ?
  3. Calculez la durée totale du catalogue avec reduce. Que se passe-t-il si vous oubliez la valeur de départ et que le tableau est vide ?
  4. Triez les formations par prix croissant, puis par titre (ordre alphabétique français). Le tableau d'origine a-t-il été modifié ? Comment l'éviter ?
  5. Écrivez parCategorie(cat) qui renvoie une fonction de filtre, puis utilisez-la pour trois catégories. Quel est l'intérêt par rapport à trois fonctions écrites à la main ?
  6. Existe-t-il une formation gratuite ? Toutes durent-elles plus de 10 heures ? Quelle méthode utilisez-vous pour chaque question, et pourquoi s'arrête-t-elle dès qu'elle connaît la réponse ?

Je vérifie / je rends :

  • ☐ Le script avec une ligne de commentaire par question.

← Les fonctions prédéfinies en JavaScriptLes closures (fermetures) →

Cet article vous a-t-il aidé ?