Discussion :

[RomainVALERI]

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

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 javascript :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 )
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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ^^

[Bovino]

Tu peux essayer avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for (var i in arguments)

[RomainVALERI]

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é ?

[Bovino]

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...

[RomainVALERI]

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 ? (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 javascript :

Sélectionner tout - Visualiser dans une fenêtre à part

all(new Object(arguments));

?
Ou bien commencer la fonction "all" par :

Code javascript :

Sélectionner tout - Visualiser dans une fenêtre à part

arg = new Object(arg);

...?

[franculo_caoulene]

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.

[RomainVALERI]

Oui, je crois malheureusement que tu as raison.

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

Merci en tout cas à vous deux ^^

[kimjoa]

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++

[RomainVALERI]

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

[marts]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 [];
	}

[RomainVALERI]

!!!

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

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

[Bovino]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Function.prototype.getArgumentsNames=function()

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[RomainVALERI]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ? ...ou bien tout le code source du fichier javascript ? (rien compris)
Si c'est bien le cas, c'est bien le "tour de force" qui m'a fait un choc tout-à-l'heure... j'espère que marts sera plus loquace demain ^^

[marts]

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

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 ! ).

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.

[RomainVALERI]

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

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 ^^

[marts]

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

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

[Bovino]

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...

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

[SpaceFrog]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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>

[marts]

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

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.

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...)

[Bovino]

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) !