Cours de Javascript 2022

Chapitre 2 - Théorie 5 : Passer des paramètres en arguments

Ce point de théorie n'est pas vraiment une nouvelle matière, et finalement vous avez déjà toutes les infos dans les fiches de théories précédentes pour comprendre ce qu'il va se passer ici, mais c'est souvent mal compris par les gens ou assez peu instinctif, c'est pour cela que vous aurez un exercice en rapport avec cette matière et cette fiche de théorie en plus.

La première chose à bien comprendre, c'est qu'une fonction peut appeler une autre fonction. C'est ce qu'on appelle du code en cascade, ainsi si on a :

function FirstFunc()
{
 //Du Code
}

function SecondFunc()
{
 //Du Code
}

On pourrait très bien avoir une troisième fonction qui fait appel aux deux autre fonctions, ainsi on aurait :

function ThirdFunc()
{
 FirstFunc()
 SecondFunc()
}

Cette troisième fonction aurait donc pour rôle d'appeler les deux premières, peut importe pour quoi, on peut imaginer toutes sortes de raison, et cela arrivera très souvent, il suffit de repenser à notre exemple avec la voiture qui veut freiner pour reculer vu plus tôt dans ce chapitre.

Jusqu'ici, rien d'exceptionnel, par contre, là où ça commence à devenir spécial, c'est lorsque toutes ces fonctions ont des paramètres. Prenons en exemple ces fonctions qui suivent, leurs rôles n'a que très peu d'importance, et je vais volontairement mettre des noms de paramètre pour comprendre qui va où, plus que pour être compréhensible pour un autre développeur.

function FonctionA(_paramA1,_paramA2)
{
 // Du code
}

function FonctionB(_paramB1,_paramB2,_paramB2)
{
 // Du code
}

On a donc une fonction appelée FonctionA qui a deux paramètres, et une fonction FonctionB qui elle en a 3. Créons maintenant une 3ème fonction qui va avoir comme rôle d'appeler ces 2 fonctions, et qui elle a conscience des valeurs qu'il faut donner à ces paramètres (c'est pour comprendre ce que l'on fait, mais ce cas est très peu probable);

function FonctionC()
{
 FonctionA(5,"Bonjour");
 FonctionB(100,"salut","coucou");
}

Dans ce cas :

• paramA1 vaudra 5
• paramA2 vaudra "Bonjour"
• paramB1 vaudra 100
• paramB2 vaudra "salut"
• paramB3 vaudra "coucou"

C'est assez simple et ça suit la logique que l'on a déjà vu. Mais imaginons maintenant qu'une fonction FonctionD() appelle aussi la fonction FonctionA() et FonctionB() mais cette fois-ci, elle même ne sait pas d'avance les valeurs qui devront êtres transmises aux fonctions appelées (ce cas peut arriver assez souvent !), bien sur, il existe le cas où ces valeurs sont calculées par cette fonction FonctionD(), auquel cas il suffira de passer les variables en arguments de la fonction correspondante, comme vu dans le chapitre précédemment mais simplement dans le scope de la fonction. Par contre, il y a un monde où cette information doit être donnée par le programme principal. Et c'est ce cas, un peu particulier qui nous intéresse, car si le programme principal ou scope principal on peut dire, est au courant des valeurs qui vont être transmises à la FonctionA() et à la FonctionB(), mais que c'est à l'aide de l'appel de la FonctionD() que l'on va appeler ces deux premières fonctions, et bien il faut d'abord transmettre ces informations à la FonctionD() pour qu'elle puisse à son tour les transmettre aux bonnes fonctions. Concrètement on pourrait avoir ce code :

function FonctionD(_paramD1,_paramD2,_paramD3,_paramD4,_paramD5)
{
 FonctionA(_paramD1,_paramD2);
 FonctionB(_paramD3,_paramD4,_paramD5);
}

Bien sur, dans le cas où FonctionD() n'a pas, elle même, besoin d'autres paramètres pour fonctionner supplémentaire, c'est un exemple simplifié, mais on pourrait rajouter 3 paramètres utiles au simple fonctionnement de la FonctionD() en elle même, ici tous les paramètres seront transmit en tant qu'arguments pour l'appel de la FonctionA() et la FonctionB(). On peut aussi imaginer qu'un seul paramètre serve d'argument à plusieurs endroits, ou toutes les combinaisons que vous voulez.

Mais pour avancer, ou plutôt, remonter d'un niveau, on doit donc aller voir l'appel de la FonctionD() depuis le scope principal, celle-ci demande donc 5 arguments, que l'on va pouvoir aller chercher par exemple dans des variables déclarées juste avant l'appel. Par exemple :

let var1=5;
let var2="Bonjour";
let var3=100;
let var4="Salut";
let var5="coucou";
FonctionD(var1,var2,var3,var4,var5);

Et au final on aurait exactement le même résultat qu'avec la FonctionC() ! Sauf que les informations auront donc été cherchées dans le scope principal, ensuite transmise en argument à la FonctionD(), puis les paramètres de la FonctionD() auront été utilisé comme argument à l'appel de la FonctionA() et la FonctionB() !

Au final on peut écrire l'égalité suivante :

• 5==var1==_paramD1==_paramA1
• "Bonjour"==var2==_paramD2==_paramA2
• 100==var3==_paramD3==_paramB1
• "Salut"==var4==_paramD4==_paramB2
• "coucou"==var5==_paramD5==_paramB3

En fait, si on prend la liste précédente ligne par ligne, en fait on peut faire la comparaison avec une course relai, ils se passent tous l'information les uns après les autres ! En effet, la valeur 5 est stockée dans var1, puis la valeur stockée dans var1 est utilisée comme argument pour remplir le paramètre _paramD1, qui est ensuite lui même utilisé comme argument pour remplir le paramètre _paramA1, et donc la valeur 5 est passée de var1 à _paramD1 et enfin à _paramA1, qui valent donc, à cet appel bien particulier, tous 5.