Les fonctions imbriquées en javascript

Luyalu Dr Diasoluka

Description

Contrairement aux langages C, en JavaScript les fonctions peuvent être imbriquées . Ceci parce qu’en JavaScript les fonctions sont des « objets de premier ordre » on dit aussi « objets de première classe » car elles peuvent être manipulées, échangées, avoir des propriétés et des méthodes, et surtout être passées en paramètre, comme tout autre objet JS. Une fonction JS, ordinaire soit-elle (càd sans propriétés ni méthodes propres), reste donc ni plus ni moins un objet Function (callable object), et inversement (tout objet est une fonction). Or justement les méthodes aussi sont ni plus ni moins des fonctions.
Outre ses méthodes, une fonction peut posséder des fonctions ordinaires imbriquées [tout comme elle peut avoir des variables locales propres]. Mais une fonction imbriquée ne peut être appelée directement que du sein de la fonction qui l’englobe, jamais du dehors de cette fonction englobante. Ceci s’applique aussi aux variables locales propres à la fonction.
Donc fonctions imbriquées et variables propres d’une fonction ne sont pas directement accessible du dehors de la fonction englobante, sauf si on les retourne implicitement avec un « return ».
Mais rappelez-vous que « return ») ne peut retourner qu’une et une seule valeur, et que pour retourner plusieurs valeurs [à une unique occasion] il faut les placer dans une structure telle que Array ou Objetde retour.

Informations

• Publié par: diasoluyalu
• Publié le: 26 février 2019
• Nombre de lectures: 4
• Langue: Français

Extrait

J.B. Dadet DIASOLUKA Luyalu Nzoyifuanga
JAVASCRIPT(ProgrammationInternet)VOL.VI
+243 - 851278216 - 899508675 - 995624714 - 902263541 - 813572818
La dernière révision de ce texte est disponible sur CD.
CHAPITRE 12 : Lesfonctionsimbriquéesenjavascript
Contrairement aux langages C, en JavaScript les fonctions
peuvent être imbriquées . Ceci parce qu’en JavaScript les
fonctions sont des « objets de premier ordre » on dit
aussi « objets de premièèère classe » car elles peuvent être
manipulées, échangées, avoir des propriétés et des
méthodes, et surtout être passées en paramètre, comme tout
autre objet JS. Une fonction JS, ordinaire soit-elle (càd
sans propriétés ni méthodes propres), reste donc ni plus
ni moins un objet Function (callable object), et
inversement (tout objet est une fonction). Or justement les
méthodes aussi sont ni plus ni moins des fonctions.
Outre ses méthodes, une fonction peut posséder des
fonctions ordinaires imbriquées [tout comme elle peut avoir
des variables locales propres]. Mais une fonction
imbriquée ne peut être appelée directement que du sein de la
fonction qui l’englobe, jamais du dehors de cette
fonction englobante. Ceci s’applique aussi aux variables
locales propres à la fonction.
Donc fffooonnnccctttiiiooonnnsss iiimmmbbbrrriiiqqquuuéééeeesss et vvvaaarrriiiaaabbbllleeesss ppprrroooppprrreeesss d’une
fonction ne sont pas directement accessible du dehors de
la fonction englobante, sauf si on les retourne
implicitement avec un « return ».
Mais rappelez-vous que « return ») ne peut retourner
qu’une et une seule valeur, et que pour retourner
plusieurs valeurs [à une unique occasion] il faut les placer
dans une structure telle que Array ou Objetde retour.
<script type="text/javascript"> "use strict";J.D.B. DIASOLUKA Nz. Luyalu JavaScript Tome-VI
let fext = p => {
let m=2;
return _ => [m, Math.pow(m , p)];
}
let exp = Math.round(Math.random()*10);
let rtvf = fext(exp);
// Initialise à la valeur de la variable « exp »
// le paramètre p de la fonction englobante fext();
// et récupération de l'adresse de la
// fonction retournée par englobante fext().
let retval = rtvf();
// Appel de la fonction « ANONYME » retournée
// par la fonction englobante.
// Cette fonction imbriquée continuera à accéder
// aux paramètres et variables locales de la
// fonction qui l'englobe.
// La valeur (une ARRAY) retournée par la
// fonction anonyme imbriquée est récupérée
// par la variable « retval ».
console.log(
retval[0] + "^" + exp + " = " + retval[1]
);
</script>
Exécution:
2^10 = 1024 test.html:28:2
Les éléments renvoyés directement comme tels (pas leur
pointeur) avec un « return » ne peuvent naturellement pas
être modifiés dans leur milieu d’origine (l’intérieur de
la fonction englobante) à partir de l’extérieur de la
fonction englobante sauf si c’est un pointeur sur eux qui
a été renvoyé (mais en JavaScript il n’existe pas de
pointeur sur variable ordinaire).
<script type="text/javascript"> "use strict";
Fonctions Imbriquées - 2 / 18 - mercredi, 7. novembre 2018 (1:04
pm)J.D.B. DIASOLUKA Nz. Luyalu JavaScript Tome-VI
let fext = p => {
let m=2;
return _ => [m, Math.pow(m , p)];
}
let exp = Math.round(Math.random()*10);
let rtvf = fext(exp);
// Initialise à la valeur de la variable « exp »
// le paramètre p de la fonction englobante fext();
// et récupération de l'adresse de la
// fonction retournée par englobante fext().
let retval = rtvf();
// Appel de la fonction « ANONYME » retournée
// par la fonction englobante.
// Cette fonction imbriquée continuera à accéder
// aux paramètres et variables locales de la
// fonction qui l'englobe.
// La valeur (une ARRAY) retournée par la
// fonction anonyme imbriquée est récupérée
// par la variable « retval ».
console.log(
retval[0] + "^" + exp + " = " + retval[1]
);
// Affichage de la valeur multiple retournée
// par la fonction imbriquée.
///////////////////////////////////////////////
// Tentative de Modification d'une fonction //
// imbriquée en dehors de la fonction //
// qui l'englobe. //
///////////////////////////////////////////////
let fprot = _ => console.log("Success");
// Définition d'une nouvelle fonction (fléchée)
Fonctions Imbriquées - 3 / 18 - mercredi, 7. novembre 2018 (1:04
pm)J.D.B. DIASOLUKA Nz. Luyalu JavaScript Tome-VI
retval.prototype = fprot;
// On colle, de l'extérieur, un prototype à
// la fonction imbriquée.
retval.prototype();
// On appelle ce prototype bien sûr
// toujours de l'extérieur.
console.dir(rtvf);
// Vérification de la configuration actuelle
// de notre fonction imbriquée, via son
// pointeur « rtvf ».
// function fext() test.html:66:3
// fext()
// length: 1
// name: ""
// <prototype>: function ()
// Nous voyons bien ci-dessus que notre
// pointeur « rtvf » représente bien (pointe sur)
// notre fonction englobante externe « fext() ».
console.dir(retval);
// Vérification de la configuration actuelle
// de notre fonction imbriquée, via son
// pointeur « retval ».
// Array [ 2, 16 ] test.html:86:3
// (2) […]
// 0: 2
// 1: 16
// length: 2
// prototype: function fprot()
// <prototype>: Array []
// Nous voyons bien que la valeur retournée par
// la fonction imbriquée et une ARRAY,
// donc une valeur multiple,
Fonctions Imbriquées - 4 / 18 - mercredi, 7. novembre 2018 (1:04
pm)J.D.B. DIASOLUKA Nz. Luyalu JavaScript Tome-VI
// et que le prototype de cette fonction
// a bel et bien été "sémaphoré" sur « frot() ».
</script>
Rappelez-vous aussi que toute instruction qui vient après
« rrreeetttuuurrrnnn » dans un même bloc d’instruction est ignoré
pour la simple et bonne raison que l’exécution ne se
poursuit pas au-delà de return, à moins d’y aller grâce
aux labels et une instruction « goto » en amont de «
return ». Mais le « gggoootttooo » est trop intrusif.
EXEMPLE 1:
Non accessibilité d’une fonction imbriquée du dehors de
sa fonction englobante.
<script type="text/javascript"> "use strict";
function personne(){
function congrats(){
console.log( "Hello");
// Hello test.html:4:13
}
congrats();
return "Englobante";
}
console.log(personne());
// Englobante test.html:10:1
console.log(congrats());
// Uncaught ReferenceError:
// congrats is not defined
console.log(personne.congrats());
// Uncaught TypeError:
// personne.congrats is not a function
</script>
Fonctions Imbriquées - 5 / 18 - mercredi, 7. novembre 2018 (1:04
pm)J.D.B. DIASOLUKA Nz. Luyalu JavaScript Tome-VI
On peut toutefois contourner certaines de ces limitations
en faisant que la fonction englobante renvoie un pointeur
sur (= adresse de) la fonction imbriquée, permettant de
l’appeler de l’extérieur de la fonction englobante,
l’adresse renvoyée pouvant éventuellement être stockée
dans une variable.
EXEMPLE 2:
<script type="text/javascript"> "use strict";
function personne(p){
function congrats(c){
console.log(p,c);
}
console.log("Appel interne de congrats('Kibinda')")
congrats("Kibinda");
// Bonjour Kibinda test.html:4:13
return congrats;
}
const r = personne("Bonjour");
console.log("Appel externe de r('Koye')")
r("Koye"); // Bonjour Koye test.html:4:13
</script>
Exécution :
Appel interne de congrats('Kibinda') test.html:8:9
Bonjour Kibinda test.html:4:13
Appel externe de r('Koye') test.html:14:1
Bonjour Koye test.html:4:13
Les membres d’une fonction ont une portée/visibilité
locale (limitée au bloc de cette fonction) : pas accessibles
du dehors de la fonction.
Vous pouvez normalement vous arranger pour éventuellement
appeler la fonction imbriquée seulement du sein-même de la
Fonctions Imbriquées - 6 / 18 - mercredi, 7. novembre 2018 (1:04
pm)J.D.B. DIASOLUKA Nz. Luyalu JavaScript Tome-VI
fonction englobante. Vous l’exécutez bien sûr, mais pas
du dehors de la fffooonnnccctttiiiooonnn eeen