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.

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

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

[rolandcire]

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 :

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 ?

[RomainVALERI]

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

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é

[rolandcire]

enfin quoique ... si j'en crois Mozilla

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 ?

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 :

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

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.

[marts]

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.