[POO] Est-il possible de récupérer les arguments muets d'une fonction ?

J'ai écrit une petite fonction introspective, un peu pour débugger, mais surtout pour m'exercer et par curiosité :P

Elle affiche dans un simple alert la liste des paramètres passés à la fonction où est placé l'appel, ainsi que l'arbre des appels (callstack, pile d'appels, appelez ça comme vous voulez ^^).
Jusque là, rien de très original, mystique ou bizarre.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// affichage de tous les paramètres passés à la fonction ( pour debuggage ) function all(arg) { var mess = "------------------------------------------\n"; mess += "Liste des arguments passés à\nla fonction " + arguments.callee.caller.name + " :\n"; mess += "(sur " + arguments.callee.caller.length + " attendus)\n\n";   for (var i = 0 ; i < arg.length ; i++) { mess += "argument numero " + (i + 1) + " : " + arg[i] + "\n"; } mess = calltree() + "\n" + mess + "\n------------------------------------------\n"; alert(mess); } function calltree() { var mess = "------------------------------------------\n"; mess += "Arbre d'appels :\n\n"; if (document.all) return mess + "(indisponible pour IE)";   var root = arguments.callee.caller.caller; var t = new Array(); while (root) { t.push(root.name); root = root.caller; } for (var i = (t.length - 1); i >= 0; i--) { for (var ii = 0; ii < ((t.length - 1) - i); ii++) { mess += " "; } mess += "appel n°" + ((t.length) - i); if (i == (t.length - 1)) mess += " (racine)"; mess += " : " + t[i] + "\n"; } return mess; }

---

Pour l'utiliser il suffit de placer dans une fonction quelconque l'appel suivant :

Code:

---

1 2	all(arguments);

---

Je l'ai testée : elle marche très bien. (edit : petit oubli : pas complètement sous IE pour le moment :aie:)
Par contre, je voudrais y ajouter une amélioration sans y parvenir pour le moment :

---> voir ma question du titre : "Est-il possible de récupérer les arguments muets d'une fonction ?"

Ce que je voudrais, c'est accéder aux identificateurs utilisés pour nommer les arguments dans la signature de la fonction.
Exemple, dans ce bout de code imaginaire :

Code:

---

1 2 3 4 5

function afficher(nom, score) { // ... }

---

Je sais récupérer le nom de la fonction, à savoir la chaîne "afficher", mais comment récupérer les chaines "nom", et "score" (attention nous sommes bien d'accord : je ne parle pas du nom "bebert" et du score "122" qui sont les valeurs passées ponctuellement à tel appel...)

Si quelqu'un a un début de piste, une idée géniale ou autre...
...en tout cas merci de m'avoir lu jusque ici ^^

Tu peux essayer avec :

Code:

---

for (var i in arguments)

---

Heu... je vois ce que tu veux faire, mais je ne comprends pas ce que ça change par rapport au fait de parcourir les propriétés de l'objet avec une boucle for "classique" : du coup je viens de faire l'essai en plaçant ta boucle juste avant ma boucle for, et contenant une seule instruction pour controler le passage( { alert(i); } ).
Résultat : pas d'alert

Autre essai en bouclant sur arg au lieu d'arguments (ce qui me semblait plus logique dans le contexte) : idem, pas d'alert :?

Quelle étape ai-je raté ? :aie:

Sur un objet, la boucle for ... in boucle sur les propriétés de l'objet, y compris ceux de sa chaîne de prototype. Mais ici, tu déclares ta fonction comme une variable et non comme un objet, donc effectivement, cela ne fonctionne pas... :cry:

Citation:

---

Envoyé par Bovino

tu déclares ta fonction

---

laquelle ?

Comme "arg" est la copie de l'objet arguments (passé par valeur à "all"), j'en avais conclu que dans une boucle (for var i in arg) { //... }, "arg" est bien un objet, non ? 8O (en tout cas un alert(arg); placé dans la fonction "all" m'affiche [Object object])
Tu pensais à quoi comme manière de forcer le type objet ? remplacer l'appel par

Code:

---

all(new Object(arguments));

---

?
Ou bien commencer la fonction "all" par :

Code:

---

arg = new Object(arg);

---

...?

En fait, je ne pense pas que ce soit possible. Si on accède aux propriétés de cet objet via un entier c'est qu'on ne peut pas y accéder via leur nom.
C'est comme si les propriétés de arguments s'appelaient :
arguments.0
arguments.1
arguments.2
etc.

Oui, je crois malheureusement que tu as raison. :cry:

J'étais déjà arrivé devant ce même "mur" quand en java j'avais essayé de savoir si on pouvait accéder aux identificateurs des variables... pas possible :aie:

Merci en tout cas à vous deux ^^

merci pour ton code,grâce a toi j'ai appris la fonction caller, et ma permis de faire ca ->
http://www.developpez.net/forums/d69...tion-methodes/

a++

Ca a l'air intéressant je vais jeter un oeil, merci du lien ;-)

Code:

---

1 2 3 4 5 6 7 8 9 10 11

Function.prototype.getArgumentsNames=function() { var m=/function ([^(]*)\(([^)]*)\)/.exec(this); if (m) { var argumentsNames=m[2].split(', '); if (argumentsNames.length && argumentsNames[0]) return argumentsNames; } return []; }

---

8O !!!

wow... là je suis un peu ému j'avoue :oops:

merci beaucoup je vais étudier ce code qui me dépasse autant qu'il me plait :mrgreen:

:koi:
Tu as testé, parce que là, soit je suis complètement dépassé, soit plusieurs trucs m'échappent :

Code:

---

Function.prototype.getArgumentsNames=function()

---

Cela implique que tu passes par un constructeur de fonction (new Function) ce qui est assez rare...

Code:

---

var m=/function ([^(]*)\(([^)]*)\)/.exec(this);

---

Tu récupères avec une regexp des éléments qui ne sont pas présents dans le code ? (Le but étant de récupérer les arguments muets)...

EDIT :

Code:

---

var argumentsNames=m[2].split(', ');

---

8O
exec() renvoie le texte en correspondance ou null... m[2] correspond à quoi ???

A ce que j'en ai compris après une première lecture attentive (mais je n'ai pas encore testé),

Code:

---

Function.prototype.getArgumentsNames=function()

---

me semble être une excellente structure à laquelle je n'avais pas pensé : je savais effectivement qu'on pouvait "dériver" les objets natifs javascript en leur ajoutant de nouvelles fonctions, mais cette utilisation ne m'est pas encore très intuitive, et je ne l'avais pas envisagé ici... en tout cas la syntaxe est régulière.

Ma connaissance des regexp est assez fraiche elle aussi, mais il me semble comprendre grosso modo comment cette regexp décrit la signature d'une fonction pour en extraire les arguments, et jusque là tout va bien...

Ce qui m'étonne surtout c'est que si je comprends bien, la référence à this au sein de la fonction désigne la chaine de caractères définissant la signature de la fonction dans le fichier ? 8O ...ou bien tout le code source du fichier javascript ? 8O8O8O (rien compris)
Si c'est bien le cas, c'est bien le "tour de force" qui m'a fait un choc tout-à-l'heure... :roll: j'espère que marts sera plus loquace demain ^^

Désolé de balancer ça comme ça, je vais essayer d'éclaircir un peu ...

Citation:

---

Envoyé par Bovino

Cela implique que tu passes par un constructeur de fonction (new Function) ce qui est assez rare...

---

Non, en fait ça marche aussi bien avec l'instruction "function" et avec l'opérateur "function" (qui utilisent tous deux le constructeur Function).
De n'importe quelle manière que ce soit, toute fonction déclarée après ça acquiert getArgumentsNames comme propriété.
Mais on n'est pas obligé de faire ça, on peut déclarer une simple fonction qui prend en argument la fonction dont on veut les arguments (c'est difficile à expliquer ! :lol:).

Citation:

---

Envoyé par RomainVALERI

la référence à this au sein de la fonction désigne la chaine de caractères définissant la signature de la fonction dans le fichier ? ...ou bien tout le code source du fichier javascript ? (rien compris)

---

this fait référence à l'objet appelant, c'est à dire la fonction à laquelle est appliquée getArgumentsNames.
En toute rigueur, j'aurais dû écrire this.toString(), qui renverrait la fonction sous forme de chaine ("function (...) {...}"), mais comme exec attend une chaine en paramètre, toString est appelé automatiquement.


Pour ce qui est de l'expression régulière, pour tout dire je ne suis pas non plus un expert et celle là n'est pas de moi (récupérée dans le code de Firebug). Mais elle est facile à comprendre.
Elle contient 2 groupes mémorisés, après "function " :
1 : ([^(]*) = tout jusqu'à la première parenthèse ouvrante (donne le nom de la fonction)
2 : ([^)]*) = tout jusqu'à la première parenthèse fermante (donne les arguments de la fonction)

Ces 2 sous-chaines sont dans le résultat de exec, qui est un tableau avec ces éléments :
0 : function exemple(arg1, arg2, arg3) (sous chaine correspondant à l'expression régulière)
1 : exemple (nom de la fonction)
2 : arg1, arg2, arg3 (arguments de la fonction)

Il suffit ensuite de splitter l'élément 2 pour avoir la liste des arguments.

Marts, est-ce que tu acceptes de m'épouser ? :lol:

Bon, bref, c'est chouette je comprends mieux l'ensemble et je vais tester ça direct ;) heu... rectification : je vais tester ça demain, ma fille se lève dans pas longtemps... au lit ^^

Citation:

---

Envoyé par RomainVALERI

Marts, est-ce que tu acceptes de m'épouser ? :lol:

---

Heu ... non, désolé, je suis déjà casé.
Mais ça me va droit au coeur. :lol:

Citation:

---

Envoyé par marts

Elle contient 2 groupes mémorisés, après "function " :
1 : ([^(]*) = tout jusqu'à la première parenthèse ouvrante (donne le nom de la fonction)
2 : ([^)]*) = tout jusqu'à la première parenthèse fermante (donne les arguments de la fonction)

Ces 2 sous-chaines sont dans le résultat de exec, qui est un tableau avec ces éléments :
0 : function exemple(arg1, arg2, arg3) (sous chaine correspondant à l'expression régulière)
1 : exemple (nom de la fonction)
2 : arg1, arg2, arg3 (arguments de la fonction)

Il suffit ensuite de splitter l'élément 2 pour avoir la liste des arguments.

---

Oui, mais là tu ne récupères pas les arguments implicites ? Juste les arguments passés en paramètre... :koi:

Ceci dit, m[2], je connaissais pas comme notation pour récupérer les back references...

Wazaaaaa comment j'ai pas été assez rapide sur ce coup là ...

j'étais parti aussi sur les regExp, je vous livre ma proposition:

Code:

---

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

<script language="JavaScript">   function choix(param1,param2, param3) {   }   Function.prototype.getArgNames=function(){ reg=/function\s+\w.*\((.*)\)/ var args=reg.exec(this); args=RegExp.$1.replace(/\s/g,'').split(',') alert(args) }   choix.getArgNames()   </script>

---

Citation:

---

Envoyé par Bovino

Oui, mais là tu ne récupères pas les arguments implicites ? Juste les arguments passés en paramètre... :koi:

---

Si tu appelles arguments implicites les arguments effectivement passés à la fonction lors de son appel, ils sont récupérables depuis l'intérieur de la fonction avec l'objet "arguments".
Là il s'agissait de récupérer les identifiants des arguments, c'est à dire les noms qu'utilise le corps de la fonction pour identifier les valeurs passées.

Citation:

---

Envoyé par RomainVALERI

Ce que je voudrais, c'est accéder aux identificateurs utilisés pour nommer les arguments dans la signature de la fonction.
Exemple, dans ce bout de code imaginaire :

Code:

---

1 2 3 4 5

function afficher(nom, score) { // ... }

---

Je sais récupérer le nom de la fonction, à savoir la chaîne "afficher", mais comment récupérer les chaines "nom", et "score" (attention nous sommes bien d'accord : je ne parle pas du nom "bebert" et du score "122" qui sont les valeurs passées ponctuellement à tel appel...)

---

:mouarf3:
J'étais complètement à l'ouest moi, je parlais depuis le début des arguments non passés en paramètres de la fonction mais quand même transmis (typiquement, l'argument event lors d'un événement) !

Citation:

---

Envoyé par Bovino

:mouarf3:
J'étais complètement à l'ouest moi, je parlais depuis le début des arguments non passés en paramètres de la fonction mais quand même transmis (typiquement, l'argument event lors d'un événement) !

---

Ca arrive même aux meilleurs ;)

Citation:

---

Envoyé par RomainVALERI

J'ai écrit une petite fonction introspective, un peu pour débugger, mais surtout pour m'exercer et par curiosité :P

Elle affiche dans un simple alert la liste des paramètres passés à la fonction où est placé l'appel, ainsi que l'arbre des appels (callstack, pile d'appels, appelez ça comme vous voulez ^^).
Jusque là, rien de très original, mystique ou bizarre.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

// affichage de tous les paramètres passés à la fonction ( pour debuggage ) function all(arg) { var mess = "------------------------------------------\n"; mess += "Liste des arguments passés à\nla fonction " + arguments.callee.caller.name + " :\n"; mess += "(sur " + arguments.callee.caller.length + " attendus)\n\n";   for (var i = 0 ; i < arg.length ; i++) { mess += "argument numero " + (i + 1) + " : " + arg[i] + "\n"; } mess = calltree() + "\n" + mess + "\n------------------------------------------\n"; alert(mess); } function calltree() { var mess = "------------------------------------------\n"; mess += "Arbre d'appels :\n\n"; if (document.all) return mess + "(indisponible pour IE)";   var root = arguments.callee.caller.caller; var t = new Array(); while (root) { t.push(root.name); root = root.caller; } for (var i = (t.length - 1); i >= 0; i--) { for (var ii = 0; ii < ((t.length - 1) - i); ii++) { mess += " "; } mess += "appel n°" + ((t.length) - i); if (i == (t.length - 1)) mess += " (racine)"; mess += " : " + t[i] + "\n"; } return mess; }

---

Pour l'utiliser il suffit de placer dans une fonction quelconque l'appel suivant :

Code:

---

1 2	all(arguments);

---

Je l'ai testée : elle marche très bien. (edit : petit oubli : pas complètement sous IE pour le moment :aie:)
Par contre, je voudrais y ajouter une amélioration sans y parvenir pour le moment :

---

Bonjour,

Ce code est à mon sens vraiment TRES intéressant... Je compte bien l'utiliser par moments. Je n'ai qu'une interrogation. Il fait appel à des éléments Javascript dépréciés (arguments.callee.caller). D'où mes questions :
- Connaissez-vous un moyen de réaliser la même chose sans ces éléments dépréciés ?
- A défaut, quel risque à moyen terme y aurait-il à inclure cette fonction dans certains développements ? Risque-t-on de se retrouver avec des erreurs sur certains navigateurs ?

Citation:

---

Envoyé par rolandcire

Bonjour,

Ce code est à mon sens vraiment TRES intéressant... Je compte bien l'utiliser par moments. Je n'ai qu'une interrogation. Il fait appel à des éléments Javascript dépréciés (arguments.callee.caller). D'où mes questions :
- Connaissez-vous un moyen de réaliser la même chose sans ces éléments dépréciés ?
- A défaut, quel risque à moyen terme y aurait-il à inclure cette fonction dans certains développements ? Risque-t-on de se retrouver avec des erreurs sur certains navigateurs ?

---

Heureux que ce bout de code puisse t'être utile :oops:

A propos des éléments depréciés : je n'avais pas vu ça début 2009 quand j'ai écrit ce code... :? Peut-être qu'ils l'étaient déjà, peut-être pas... je l'ignore... en tout cas : il va falloir que je vérifie.

Merci de l'info, le premier qui trouve quelquechose qui peut faire avancer l'affaire... a le droit de le poster ici je ne serai même pas fâché :mrgreen:

enfin quoique ... si j'en crois Mozilla

Citation:

---

JavaScript 1.4 : callee est obsolète en tant que propriété de Function.arguments, et devient une propriété de la variable locale arguments propre à chaque fonction.

---

https://developer.mozilla.org/fr/R%C...guments/callee

en outre Safari 4 ne semble pas supporter
arguments.callee.caller

Bref, pas simple, je continue

Edit -------------------------------
Cela semble finalement bon pour callee, mais pas pour caller ? :oops:

https://developer.mozilla.org/En/Cor...cope/arguments

Pour caller, cela semble implémenté en Javascript 1.5 pour les moteurs SpiderMonkey (cf. les navigateurs Mozilla) et JScript sous la forme suivante :

Code:

---

1 2 3 4 5 6 7 8

ma fonction1 () { alert(mafonction.caller); }   mafonction2 (){mafonction1();}   mafonction2(); //affiche mafonction1

---

Source : https://developer.mozilla.org/en/Cor...unction/caller


Mais ce n'est pas standard. C'est sans doute pourquoi d'autres moteurs comme celui de Safari4 semblent ne plus l'implémenter.

La question rebondit donc. Comment identifier la fonction appelante d'une autre fonction en respectant les standard.

La version actuelle de javascript est basée sur la 3ème édition du standard Ecmascript (qui date de 99 et qui définit "callee" mais pas "caller").
La propriété "caller" n'apparait que dans la 5ème édition du standard, qui date de ... septembre dernier. Donc il va falloir attendre un peu avant que tous les navigateurs l'intègrent.