javascript tome xxiii - Gestions de paramètres et nom de fonctions

Gestions de paramètres et
noms de fonctions
JAVASCRIPT (Programmation Internet) VOL. III
Po u r D é b u t a n t s
J.B. Dadet DIASOLUKA Luyalu Nzoyifuanga
+243 - 851278216 - 899508675 - 995624714 - 902263541 - 813572818
La dernière révision de ce texte est disponible sur CD.
CHAPITRE 10 : Les FONCTIONS dans JavaScript
Une fonction est un bloc de texte plutôt de code et données (aussi appe-
lée « sous-programme ») que le navigateur interprète comme instruc-
tions pour exécuter une tâche précise, et que l’on peut appeler autant de
fois au besoin à partir de n’importe où : de l’extérieur de la fonction
(call) ou du sein de la fonction même (récursion) ou d’un autre fichier
(fichier externe : bibliothèques / frameworks...).
Une fonction requiert deux conditions :
1. Elle doit être déclarée/définie. En JS
a. La déclaration d’une fonction (ou instruction de fonction) : lui
donner un nom-identificateur et une adresse-mémoire
b. et Sa définition : la description de sa structure et de son fonc-
tionnement interne (y compris ses paramètres, son unique va-
leur de retour, ses variables locales, les traitements effectués...)
logée à l’adresse-mémoire lui affectée.
2. Elle doit par la suite être explicitement appelée. Une fonction ne
peut pas s’exécuter toute seule à moins qu’elle soit inline..
a. Même quand elle est récursive, la fonction doit s’appeler du sein
d’elle-même

Gestions de paramètres et noms de fonctions
DIASOLUKA Nz. Luyalu -2/42- JavaScript T.-III
b. Même quand elle est inline, elle est en fait explicitement appelée
à la fin de sa déclaration/définition, par les parenthèses termi-
nales.
Des fonctions peuvent être prédéfinies dans le navigateur ou le compila-
teur (natives), un fichier d’entête (bibliothèque), un API (Applications
Programmers Inteface), un objet (méthodes)...
On peut plus facilement comprendre un appel à une fonction comme
étant une instruction unique exécutant une série d’autres fonctions et
instructions prédéterminées et regroupées dans le corps de la fonction
appelée lors de la définition de cette dernière.
La définition d’une fonction est reconnaissable par une paire de paren-
thèses (vide ou non), suivie d’une paire d’accolades (curly brackets,
vide ou non). Le contenu de la paire de parenthèse représente les para-
mètres formels, et le contenu du bloc des accolades est le code ou corps
de la fonction. Le corps de la fonction peut aussi être vide.
Une fonction sert habituellement à effectuer une tâche répétitive, et re-
tourne (renvoie) obligatoirement une valeur, implicitement via
l’instruction return, habituellement le résultat de la tâche effectuée par
la fonction. Par exemple la fonction sin(x) retourne le sinus de la valeur
représentée par l’argument x, la fonction factorielle(x) retourne la facto-
rielle du nombre en argument.
La valeur retournée par une fonction peut être de n’importe quel type
légal (par défaut undefined), et en particulier une autre fonction
(l’adresse-mémoire de cette dernière) ou d’elle-même (fonctions récur-
sives), une Array (p.ex. « return [v1,v2...] »), un objet (p.ex. return
{x:val}), une propriété d’objet (p.ex. « return obj.attr »), une chaîne
[de caractère] (p.ex. « return "chaîne" », un nombre p.ex. « return
5 »,... ) ces valeurs de retour pouvant être représentée par des variables
ou des constantes (chaînes ou scalaires).

Gestions de paramètres et noms de fonctions
DIASOLUKA Nz. Luyalu -3/42- JavaScript T.-III
Syntaxe générique de déclaration/définition d’une fonction :
function nom_fonction ( arguments0, arguments1, ... argumentsN ) {
/* Corps de la fonction = série d’instructions et
de variables internes = locales */
}
Il y a deux façons de déclarer une fonction en JS : Comme fonctions
nommée (ayant un nom identifiant ou comme fonction anonyme.
I. Fonctions NOMMÉES :
<script type="text/javascript">
"use strict";
/* I.1. */ function foo(p){ p() }; // Classique.
/* I.2. */ var fob = function(){}; // Affectée.
/* I.3. */ var foc = () => {}; // Fléchée.
</script>
En fait, seule la foo() dans I.1. est une fonction nommée. fob dans I.2. et
foc dans I.3. (fonction fléchée) sont des pointeurs (alias) sur fonction
anonyme, ou alias de la fonction.
Voici l’architecture interne de ces fonctions, particulièrement la valeur
de leur propriété « nom » :.
De fonction anonyme ou pas, les pointeurs sur fonction représentent la
fonction-même (répondent à la place de la fonction).
a. Object.getOwnPropertyDescriptors(foo)
1er {length: {…}, name: {…}, arguments: {…}, caller: {…}

Gestions de paramètres et noms de fonctions
DIASOLUKA Nz. Luyalu -4/42- JavaScript T.-III
, prototype: {…}}
A argu-
ments:{value: null, writable: false, enumerable: fals
e, configurable: false}
B cal-
ler:{value: null, writable: false, enumerable: false,
configurable: false}
C length:{value: 1, writable: false, enumerable: false,
configurable: true}
D name:{value: "foo", writable: false, enumerable: fals
e, configurable: true}
E proto-
type:{value: {…}, writable: true, enumerable: false,
configurable: false}
F __proto__:Object
b. Object.getOwnPropertyDescriptors(fob)
1er {length: {…}, name: {…}, arguments: {…}, caller: {…}
, prototype: {…}}
A argu-
ments:{value: null, writable: false, enumerable: fals
e, configurable: false}
B cal-
ler:{value: null, writable: false, enumerable: false,
configurable: false}
C length:{value: 0, writable: false, enumerable: false,
configurable: true}
D name:{value: "fob", writable: false, enumerable: fals
e, configurable: true}
E proto-
type:{value: {…}, writable: true, enumerable: false,
configurable: false}
F __proto__:Object

Gestions de paramètres et noms de fonctions
DIASOLUKA Nz. Luyalu -5/42- JavaScript T.-III
c. Object.getOwnPropertyDescriptors(foc)
1er {length: {…}, name: {…}}
A length:{value: 0, writable: false, enumerable: false,
configurable: true}
B name:{value: "foc", writable: false, enumerable: fals
e, configurable: true}
C __proto__:Object
II. Fonctions ANONYMES :
<script type="text/javascript">
"use strict";
/* II.1. */ (function(){})(); // Inline.
/* II.2. */ !function(){}(); // Exécution immédiate.
/* II.3. */ function fob(){ // FCT NOMMÉE
foo( // fob() appelle foo() (son arg= fct anonyme).
function(){console.log(Math.E)} // FCT ANONYME
)
}
fob(); // Appel de fob() juste ci-dessus.
</script>
Une fonction anonyme est naturellement une fonction sans nom. Voici la
structure d’une fonction anonyme comme telle, sa propriété name n’est
qu’une chaîne vide.
Object.getOwnPropertyDescriptors ( function(p1,p2) {
alert ( p1 ( p2 ))
})
1er {length: {…}, name: {…}, arguments: {…}, caller: {…}
, prototype: {…}}
A argu-