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

Les arguments et les fonctions anonymes

Les arguments et les fonctions anonymes. Dans cette leçon du cours JavaScript, vous apprendrez à : comprendre comment les arguments sont transmis à une fonction ; savoir ce qu'est l'objet arguments et...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Les arguments et les fonctions anonymes. Dans cette leçon du cours JavaScript, vous apprendrez à : comprendre comment les arguments sont transmis à une fonction ; savoir ce qu'est l'objet arguments et pourquoi on lui préfère le paramètre rest ; utiliser des fonctions anonymes comme valeurs ; reconnaître et écrire une fonction exécutée immédiatement (IIFE).

Chapitre 10 — Les fonctions en JavaScript · Les arguments et les fonctions anonymes

🎯 Objectifs de la leçon
• comprendre comment les arguments sont transmis à une fonction ;
• savoir ce qu'est l'objet arguments et pourquoi on lui préfère le paramètre rest ;
• utiliser des fonctions anonymes comme valeurs ;
• reconnaître et écrire une fonction exécutée immédiatement (IIFE).

1. La transmission des arguments

À l'appel, chaque paramètre reçoit une copie de la valeur de l'argument correspondant. Pour un nombre, une chaîne ou un booléen, modifier le paramètre dans la fonction ne change donc rien à l'extérieur. Mais un tableau ou un objet est transmis par référence: la fonction reçoit une copie de l'adresse, et peut donc modifier le tableau d'origine.

// 1. Paramètres et arguments
function presenter(prenom, groupe) {          // paramètres : des noms
  return `${prenom} (${groupe})`;
}
console.log(presenter("Karim", "DEV101"));     // arguments : des valeurs

// 2. Les arguments sont passés par valeur… mais un objet est une référence
function modifier(nombre, tableau) {
  nombre = 99;          // ne change que la copie locale
  tableau.push(99);     // modifie le tableau d'origine
}
let n = 1;
const t = [1];
modifier(n, t);
console.log("Après modifier : n =", n, "| t =", t);

// 3. L'objet arguments (ancienne syntaxe, seulement dans les fonctions function)
function sommeAncienne() {
  let total = 0;
  for (let i = 0; i < arguments.length; i++) total += arguments[i];
  return total;
}
console.log("sommeAncienne(1, 2, 3, 4) =", sommeAncienne(1, 2, 3, 4));
console.log("arguments est-il un tableau ?", (function () { return Array.isArray(arguments); })(1, 2));

// 4. Les fonctions anonymes : une fonction sans nom, utilisée comme valeur
const carre = function (x) { return x * x; };
console.log("carre(7) =", carre(7), "| carre.name =", JSON.stringify(carre.name));

setTimeout(function () {
  console.log("Une fonction anonyme passée à setTimeout s'exécute plus tard");
}, 0);

console.log("Tri décroissant :", [3, 11, 7].sort(function (a, b) { return b - a; }));

// 5. Une fonction anonyme exécutée immédiatement (IIFE)
const compteur = (function () {
  let valeur = 0;                       // variable privée
  return { suivant: function () { valeur++; return valeur; } };
})();
console.log("IIFE :", compteur.suivant(), compteur.suivant(), "| valeur inaccessible :", compteur.valeur);

// 6. Une fonction anonyme nommée : le nom est visible à l'intérieur (récursivité, débogage)
const factorielle = function fact(k) { return k <= 1 ? 1 : k * fact(k - 1); };
console.log("factorielle(5) =", factorielle(5));

Résultat dans la console

Karim (DEV101)
Après modifier : n = 1 | t = [ 1, 99 ]
sommeAncienne(1, 2, 3, 4) = 10
arguments est-il un tableau ? false
carre(7) = 49 | carre.name = "carre"
Tri décroissant : [ 11, 7, 3 ]
IIFE : 1 2 | valeur inaccessible : undefined
factorielle(5) = 120
Une fonction anonyme passée à setTimeout s'exécute plus tard

2. L'objet arguments

Dans une fonction déclarée avec function, la variable spéciale arguments contient tous les arguments reçus, même ceux qui ne correspondent à aucun paramètre. C'est une ancienne technique : arguments ressemble à un tableau mais n'en est pas un (pas de map, pas de reduce), et elle n'existe pas dans les fonctions fléchées. Aujourd'hui, on utilise le paramètre rest (...valeurs), qui est un vrai tableau (leçon 10.4). Vous rencontrerez encore arguments dans du code ancien.

3. Les fonctions anonymes

Une fonction anonyme est une fonction sans nom. En JavaScript, une fonction est une valeur comme une autre : on peut la ranger dans une variable, la passer en argument ou la renvoyer. Les fonctions anonymes servent surtout :

  • à créer une expression de fonction: const carre = function (x) { … } (leçon 10.5) ;
  • à passer un traitement à une autre fonction : setTimeout(function () { … }, 1000), tableau.sort(function (a, b) { … }) (leçon 10.7) ;
  • à exécuter un bloc tout de suite dans sa propre portée : l'IIFE (Immediately Invoked Function Expression), entourée de parenthèses et appelée aussitôt (function () { … })(). Elle servait à créer des variables privées avant l'arrivée des modules (chapitre 17).

Une fonction anonyme peut quand même recevoir un nom (function fact(k) { … }) : il n'est visible qu'à l'intérieur, ce qui permet la récursivité et rend les messages d'erreur plus clairs.

ℹ️ À retenir
• Les valeurs simples sont copiées ; les objets et tableaux sont partagés (référence).
• arguments: ancienne syntaxe, pas un vrai tableau, absente des fléchées ; préférez ...rest.
• Une fonction anonyme est une valeur : variable, argument, valeur de retour.
• IIFE : (function () { … })() crée une portée privée exécutée immédiatement.

🛠 Activité 3 — Des fonctions comme des valeurs

Mission : Explorez la transmission des arguments et l'usage des fonctions anonymes à travers de petits programmes.

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

  1. Écrivez ajouterNote(notes, note) qui ajoute une note à un tableau. Le tableau d'origine est-il modifié ? Écrivez une version qui renvoie un nouveau tableau sans modifier l'original (indice : spread).
  2. Écrivez incrementer(n) qui fait n++. Pourquoi la variable passée en argument ne change-t-elle pas ?
  3. Écrivez sommeAncienne() avec arguments, puis somme(...nombres) avec le paramètre rest. Essayez arguments.reduce: que se passe-t-il ?
  4. Rangez trois fonctions anonymes (addition, soustraction, multiplication) dans un objet operations. Comment appelez-vous l'opération dont le nom est dans une variable choix?
  5. Triez un tableau de prénoms par longueur avec sort et une fonction anonyme. Que doit renvoyer la fonction de comparaison ?
  6. Écrivez une IIFE qui calcule et affiche la date du jour au chargement du script, sans laisser aucune variable globale. Comment vérifiez-vous dans la console qu'aucune variable n'a « fui » ?

Je vérifie / je rends :

  • ☐ Le fichier de tests et les réponses aux questions 2 et 3.

← Variables globales et variables localesLes paramètres par défaut et les paramètres rest →

Cet article vous a-t-il aidé ?