Nombre d'arguments variable

Bonjour à tous,
J'ai un tp à faire dans le cadre de mes études en informatique.
Ci dessous, le code JavaScript.
J'ai implementer la function sub() sans trop de soucis, en revanche je doit modifier la fonction adder afin qu'elle acceptee un nombre variable d'argument tel que :

Code:

---

1 2 3 4 5 6

adder()(0); // 0 adder()(1); // 0 adder(mult(2))(1); // 2 adder(mult(2), mult(2))(1); // 4 adder(mult(2), mult(2), mult(2))(1); // 6 adder(mult(2), sub(2), mult(2))(1); // 5

---

Mon professeur m'indique d'utiliser :
-->

Code:

---

1 2	var args = Array.prototype.slice.call(arguments); [1,2,3].forEach(function(val){console.log(val);});

---

Mais je ne comprend pas trop.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

function adder(l,r){ return function(v){ return l(v) + r(v); } }   function mult(v){ return function(e){ return v*e; } } function sub(x,y) { return x-y; } console.log(adder(mult(2), mult(4))(2)); console.log(sub(0,0)); console.log(sub(2,1)); console.log(sub(2,2)); console.log(sub(2,4));

---

Pouvez vous m'aider s'il vous plait ?
Merci d'avance.

Ton prof t'a donné tout ce dont tu as besoin
La première ligne récupère les arguments passés dans la fonction en cours sous forme d'Array.
La seconde montre comment exécuter facilement une fonction sur chaque élément d'un Array. Bien qu'une boucle for fait tout aussi bien dans ton cas.

Je ne suis pas fan du prototype ...
personnellement quand j'ai besoin de passer un nombre d'arguments variable je passe un json ...

fan du prototype ? tu veux dire caster les arguments en Array ? Je ne vois quel est le problème avec ça. Ca me parait tout à fait approprié pour le problème de la calculatrice en notation polonaise.

Code:

---

Array.prototype

---

je n'aime pas surcharger, j'ai eu trop de surprises pars le passé

j'ai juste pris l'habitude des passer un json en paramètre ce qui me parait beaucoup plus souple et moins contraignant et ne génère aucune surprise par la suite

Mais ici on ne surcharge rien du tout. On appelle simplement la fonction slice issue du prototype d'Array pour obtenir les arguments de la fonction sous la forme d'une Array. C'est quelque-chose de tout à fait courant :?

:aie:
en effet pas de surcharge... c'est juste prototype qui me colle des boutons ...

Code:

---

var args = [].slice.call(arguments);

---

Ca va mieux :aie:

oui ^^ merci

Je ne comprend vraiment pas comment faire
Je met le tableau ici, en placant arguments en parametre de la fonction, est-ce bon ?

Code:

---

1 2 3 4 5 6 7

function adder(arguments){ var args = Array.prototype.slice.call(arguments);   return function(v){ return l(v) + r(v); }

---

arguments contient la liste des arguments passé en fonction, il est inutile de l'indiquer dans la déclaration. Peut-être que ceci vous mettra sur la voie :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

function adder(){ var args = Array.prototype.slice.call(arguments);   for(var a=0; a<args.length; a++){ alert(args[a]); }   }   adder(1,2,3);

---

Moi aussi le prototype m'ennuie, mais pour une autre raison. Ça me dérange d'avoir recours à la méthode slice alors qu'au final on ne slice pas le tableau.

Les navigateurs pas trop vieux proposent des méthodes génériques pour Array, notamment une version générique de forEach. Ça fait du code plus court :

Code:

---

1 2 3 4 5 6 7

function adder() { … Array.forEach(arguments, function(arg) { … }); … }

---

La méthode reduce est à mon goût la plus élégante pour résoudre ce genre de problème, mais elle est peut-être un peu difficile à comprendre au début. Il y a aussi map qui peut être intéressante.

Oui c'est sûr que Array.reduce est plus approprié ici, il suffit d'écrire

Code:

---

1 2 3

function adder() { return [].reduce.call(arguments, function(res, arg){ return res+arg; }); }

---

Je pense que le prof a parlé du slice car c'est un moyen générique de récupérer les arguments sous forme de vraie Array ; le genre de trucs qu'on peut réutiliser partout sans risques.

reduce aussi a une version générique :

Code:

---

1 2 3

function adder() { return Array.reduce(arguments, function(res, arg){ return res + arg; }); }

---

Dans l'enseignement on s'en fout que ça marche sous IE4, l'important c'est que l'élève comprenne. Et quitte à enseigner une technologie qui évolue rapidement telle que JavaScript, autant enseigner les pratiques modernes.

Tiens tant qu'à faire, on a les fonctions lambda :

Code:

---

function adder() Array.reduce(arguments, function(res, arg) res + arg);

---

Ou même carrément les fonctions arrow du futur standard ES6 :

Code:

---

function adder() => Array.reduce(arguments, (res, arg) => res + arg);

---

Citation:

---

Envoyé par Watilin

Dans l'enseignement on s'en fout que ça marche sous IE4, l'important c'est que l'élève comprenne. Et quitte à enseigner une technologie qui évolue rapidement telle que JavaScript, autant enseigner les pratiques modernes.

---

Oui mais non. Assurer le support des anciens navigateurs, ça fait partie de l'enseignement. Je n'ai pas trop envie de voir débarquer un stagiaire dans ma boîte qui commence à coder en ES6 sans savoir ce qu'est un polyfill. A ce niveau là de l'enseignement, on prépare l'élève au monde de l'entreprise. Et dans le monde de l'entreprise, il n'y a pas beaucoup de monde qui peut se permettre le luxe de lâcher le support d'IE8.

Par ailleurs, les versions génériques des méthodes d'Array ne font pas partie des normes EcmaScript5 (voir https://developer.mozilla.org/en-US/...eneric_methods).

Et pour l'onanisme intellectuel, cette technique a un nom : le Currying (Curryfication en français)