Javascript et les arguments optionnels
July 23, 2008 – 5:57 pmArguments optionnels
Une astuce que je viens d’utiliser il y a quelques minutes et sur laquelle j’avais dis que j’ecrirais une introduction..
La voila donc.
Mettont que nous ayons besoin de trier une liste. Pour ce faire, nous créons une méthode qui s’occupe de trier la liste, puis de la retourner ( dans l’exemple, la fonction fait juste appel à la méthode sort de la liste, mais on imagine la déclaration d’une vrai méthode de tri puis de son exécution )
On obtientrait donc quelque chose de ce type :
mySort = function(l){
l.sort();
return l;
};
>>> mySort([4,2,3]);
[2,3,4]
Cependant, plus tard lors de notre développement, apparait un autre besoin : il faudrait pouvoir trier la liste, mais en sens inverse cette fois-ci.
Plusieurs solutions apparaissent alors :
La premiere serait de séparer les deux étapes, en effectuant d’abord l’appel à mySort(), puis ensuite à myReverse() par exemple ( qui, ferait d’ailleurs simplement return l.reverse() dans cet exemple très basique ). Mais cela allourdirait le code.
La seconde est de rajouter un second paramètre à mySort, pour spécifier l’ordre dans lequel on veut trier la liste.
On obtiendrait alors quelque chose de ce genre :
mySort = function(l, order){
l.sort();
if(order=="reverse") l.reverse();
return l;
};
>>> mySort([2,4,3], “normal”)
[2,3,4]
>>> mySort([2,4,3], “reverse”)
[4,3,2]
On observe effectivemment qu’en fonction du second paramètre ( “normal” ou “reverse” ), le sens du tri est, ou non, inversé.
Seulement voila, cela oblige à passer un second parametre à chaque appel de sa méthode. Paramètre au final inutile si on veut trier la liste ’simplement’, sans l’inverser.
Et bien en fait (oh surprise!) non.
En effet, une astuce trop peu connue des débutants est l’utilisation de paramètres optionnels. Un paramètre contenu dans la déclaration d’une méthode et non envoyé lors de l’appel de cette dernière ne pose,en fait, pas de problème. La variable est simplement considérée comme étant à la valeur null.
exemple :
f = function(a){
return a
}
>>> f(2)
2
>>> f()
null
On constate qu’effectivemment, quand le paramètre ‘a’ n’est pas envoyé à la fonction ‘f’, ‘a’ est quand meme défini, et a la valeur null, dans le corps de la fonction. En exploitant cela, on peut modifier notre méthode de tri pour obtenir la suivante :
mySort = function(l, reverse){
l.sort();
if(reverse) l.reverse();
return l;
};
>>> mySort([2,4,3])
[2,3,4]
>>> mySort([2,4,3], “reverse”)
[4,3,2]
A noter qu’ici, la variable reverse est utilisé comme un flag : dans l’exemple on lui donne la valeur “reverse”, mais un simple “true” aurait suffit ( même si “reverse” aide à la lisibilitée du code )
Utilisation de la variable argument
Au passage, une autre astuce (un peu plus avancée celle la) concernant les arguments en javascript : dans une fonction, la variable ‘arguments’ contient la liste des arguments qui ont été passés.
Très simplement :
myTest2 = function(){
return arguments;
};
>>> myTest2()
null
>>> myTest2(1,2,3)
[1,2,3]
Et cela marche quelque soient les arguments ‘normallement’ définis :
myTest2 = function(a,b){
return arguments;
};
>>> myTest2()
null
>>> myTest2(1,2,3)
[1,2,3]
Arguments est une liste tout ce qu’il y a de plus classique : on peut connaitre sa taille avec arguments.length, et on recupère un élement avec arguments[position].
Concretement, cela permet d’envoyer un nombre variable de paramètres.
Par exemple, on peut envisager une fonction qui additionne un nombre quelconque de variables.
Additionner = function(){
var sum = 0;
for(var i=0; i < arguments.length; i++){
sum += arguments[i];
}
return sum;
};
>>> Additionner()
0
>>> Additionner(1,2)
3
>>> Additionner(1,2,3)
6
>>> Additionner(1,2,3,6,12,48)
72
On constate bien qu’on peut passer un nombre variable de paramètres, et que le résultat de la méthode est la somme de tous.
Spark.