Vous êtes sur la page 1sur 42

Gestions de paramètres et

noms de fonctions

J AVA S C R I P T (Programmation Internet) V O L . I I I


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

DIASOLUKA Nz. Luyalu -2/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
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: {…}


DIASOLUKA Nz. Luyalu -3/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
, 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

DIASOLUKA Nz. Luyalu -4/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
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-
DIASOLUKA Nz. Luyalu -5/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
ments:{value: null, writable: false, enumerable: fals
e, configurable: false}
B cal-
ler:{value: null, writable: false, enumerable: false,
configurable: false}
C length:{value: 2, writable: false, enumerable: false,
configurable: true}
D name:{value: "", writable: false, enumerable: false,
configurable: true}
E proto-
type:{value: {…}, writable: true, enumerable: false,
configurable: false}
F __proto__:Object

Les fonctions fléchées sont TOUJOURS anonymes :


(pouvant pourtant être « expression de fonction »).

Object.getOwnPropertyDescriptors(() => {})

1er {length: {…}, name: {…}}


A length:{value: 0, writable: false, enumerable: false,
configurable: true}
B name:{value: "", writable: false, enumerable: false,
configurable: true}
C __proto__:Object

Autres fonctions anonymes :

Object.getOwnPropertyDescriptors( (function(){})() )

YANDEX :
VM187:1 Uncaught TypeError: Cannot convert undefined
or null to object
at Function.getOwnPropertyDescriptors (<anony-
mous>)

DIASOLUKA Nz. Luyalu -6/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
at <anonymous>:1:8

FIREFOX :
TypeError: can't convert undefined to object

La syntaxe de définition d’une fonction est comme suit :

Le mot clé « function », le nom (identifiant de votre goût) de la fonc-


tion (sauf quand il s’agit de fonction anonyme) suivi d’une paire de pa-
renthèses (pouvant contenir une liste de paramètres formels séparés par
des virgules), suivie directement (éventuellement avec des espaces)
d’une paire d’accolades (le corps de la fonction) entre lesquelles se
trouve le contenu (instructions et données) de la fonction.

<script type="text/javascript">
function f_id(){
// corps de la fonction
}
</script>

ou alternativement le nom (identifiant) de la fonction peut précéder, plu-


tôt on affecte l'adresse de la fonction (pointeur) à une variable ou autant
de variables que l’on veut. Ces variables ne sont en fait pas des identi-
fiants de fonction, mais des « pointeurs sur fonctions anonymes»; en
d’autres termes « alias de fonction ».

<script type="text/javascript">
v_f_id = function (){
// corps de la fonction
}
</script>

On appelle la fonction par son identifiant et éventuellement avec des


arguments entre parenthèses, comme ceci :

DIASOLUKA Nz. Luyalu -7/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
<script type="text/javascript">
function f_date(d,m,y){
return new Date(y,m-1,d)
}
</script>

<script type="text/javascript">
f_age = function (a){
return (new Date()-a)/(1000*3600*24*365.2475);
}

date=f_date(27,7,2005);
age=f_age(new Date(2005,7,27));

console.log(date);
console.log(age+" ans.");
</script>

Exécution :

Wed Jul 27 2005 00:00:00 GMT+0100 (Paris, Madrid) this.html:17


12.352855437858855 ans. this.html:18

Déf. : Un argument d’une fonction est un paramètre passé à la fonc-


tion appelée par une instruction appelante, et qui est réceptionnée dans la
fonction appelée par le paramètre formel qui se trouve à la même posi-
tion (même numéro d’ordre) que dans la liste d’arguments..

Une fonction est appelée pour effectuer une tâche dont le résultat peut
être retourné par la fonction et doit être stocké dans une variable ou utili-
sé directement dans un calcul ou être directement affiché, envoyé vers le
paramètre d’une autre fonction comme argument... Par défaut (quad il
n’y a pas de directive return ou quand return ne spécifie pas une valeur
de retour) la fonction retourne « undefined ».

Une fonction peut avoir ses propres variables, on les appelle « variables
locales », ces variables locales peuvent avoir une accessibilité (visibilité)
DIASOLUKA Nz. Luyalu -8/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
limitée à son bloc quand elles sont déclarées avec le mot-clé var (va-
riables locales au vrai sens du mot), ou se faire voir ou accéder à partir
de n’importe où (se comportent comme des variables globales).

Une fonction peut être imbriquée dans une autre (et ainsi de suite), leurs
variables locales à visibilité globales peuvent être accédées l’une par
l’autre et vice-versa.

(Attention : les déclarateurs « let » et « const » ne permettent l’accès que


du sein du bloc dans lequel la variable a été déclarée et les blocs imbri-
qués, mais pas aux blocs englobants. Le déclarateur « var » interdit la
visibilité de la variable à partir de l’espace global. Mais tout cela dépend
aussi si on travaille en mode « slope » ou en mode « use strict »).

Toute fonction peut même accéder aux variables non var de n’importe
quelle autre fonction, et ses variables non var peuvent être accédées en
dehors de toute fonction (dans l’espace global).

En JS « fonction » et « objet » ne sont qu’une et même chose. Un objet-


propriété (membre) est créé chaque fois qu’on définit une fonction dite
« ordinaire », exactement de la même façon que quand on crée un objet.
Les fonctions sont ainsi dites « objets de première classe » car elles
peuvent être manipulées, échangées comme tout autre objet : avoir des
propriétés et méthodes, assignées à des variables ou éléments d’arrays
ou membres (propriétés) d’autres objets ou même d’autres objets, passer
en arguments à d’autres fonctions, ou être la valeur de retour d’une autre
fonction, comme tout autre « objet JS ». Une fonction JS ordinaire soit-
elle est donc ni plus ni moins un[e instance d’] objet un « callable ob-
ject » (objets fonction). Les fonctions sont aussi surnommées « first
class citizen ».

Une fonction est dite de haut rang (High Order Function) si elle ré-
pond à au moins un de ces critères :

1. Peut être créée au temps d’exécution (runtime)


2. Peut être affectée (assignée) à une variable :
DIASOLUKA Nz. Luyalu -9/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
i. La fonction inline immédiatement invoquée
(function(){})() n’est pas une fonction de haut rang.

1. Peut être passée en argument à une autre fonction


2. Peut être retournée comme résultat à une fonction

Exemples de fonctions de haut rang : map, reduce, filter...

Notez :

I. (function(){}()) est une « fonction » inline « à invocation immé-


diate ». C’est une simple succession de texte-code exécutée pendant
le parsing du code source, puis il est rejeté, oublié. Ce n’est pas un
objet comme tel.

II. _=>{} est une fonction fléchée configurée comme une véritable
fonction, c’est-à-dire un « callable object ».

<script type="text/javascript"> "use strict";


console.log((function(){}()) instanceof Object)
// false

console.log((_=>{}) instanceof Object)


// true
</script>

Exemple d’une fonction «pure» utilisée comme objet :

<script type="text/javascript">
var Fruit = function(n,s){
// Variables locale
couleur= "rouge";
poids= 50;

console.log("Appel via "+s)

DIASOLUKA Nz. Luyalu -10/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
};

// Appel d'une fonction se retournant cô objet


pomme=Fruit(10 , "CONSTRUCTEUR");

// Appel de la fonction Fruit via pomme


// TypeError: pomme is undefined
// console.log(pomme.couleur);

// Appel direct de la Fruit fonction


// TypeError: pomme is undefined
console.log(Fruit.couleur);

////////
// Appel de la fonction ORDINAIRE

Fruit(null , "ORDINAIRE");

r = pomme instanceof Fruit;


console.log("pomme instanceof Fruit = "+r);
console.log("pomme instanceof Fruit = "+
eval(pomme instanceof Fruit));
</script>

Exécution :

Appel via CONSTRUCTEUR


undefined
Appel via ORDINAIRE
pomme instanceof Fruit = false
pomme instanceof Fruit = false

Ici l’instance est créé avec « new » :

<script type="text/javascript">
var Fruit = function(n,s){
couleur="jaune"
console.log("Couleur = "+couleur)
}
DIASOLUKA Nz. Luyalu -11/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions

// Créer une instance-objet de cette fonction


pomme=new Fruit();

// Appel de la fonction Fruit via pomme


// TypeError: pomme is undefined
console.log(pomme.couleur);

// Appel direct de la Fruit fonction


// TypeError: pomme is undefined
console.log(Fruit.couleur);

////////
// Appel de la fonction ORDINAIRE
Fruit();

r = pomme instanceof Fruit;


console.log("pomme instanceof Fruit = "+r);
console.log("pomme instanceof Fruit = "+
eval(pomme instanceof Fruit));
</script>

Exécution :

Couleur = jaune
undefined
undefined
Couleur = jaune
pomme instanceof Fruit = true
pomme instanceof Fruit = true

Exemple d’une fonction qui se retourne elle-même :

Dans cet exemple on voit :

1) La fonction qui se retourne elle-même avec l’opérateur « this ».


DIASOLUKA Nz. Luyalu -12/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
2) La récursion qui calcule ici la factorielle du nombre en argument.
3) La redéfinition (écrasement) de la fonction « toString() ».

<script type="text/javascript">
var Fruit = function(n,s){
// Variables locale
couleur= "rouge";
poids= 50;

// Ds [ toString= function() { ] ci-dessous


// n est argument de la fonction ordinaire Fruit
toString= function() {
if(n==1) return 1;
else return n * toString(n--);
}
console.log("Appel via "+s)
return this; // retourne la fonction-même.
};

// Appel d'une fonction se retournant cô objet


pomme=Fruit(10 , "CONSTRUCTEUR");

// Appel direct de la fonction imbriquée toString()


console.log(pomme.toString("IMBRIQUÉE"));

////////
// Appel de la fonction ORDINAIRE

Fruit(null , "ORDINAIRE");

r = pomme instanceof Fruit;


console.log("pomme instanceof Fruit = "+r);
console.log("pomme instanceof Fruit = "+
eval(pomme instanceof Fruit));
</script>

Exécution :

DIASOLUKA Nz. Luyalu -13/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
Appel via CONSTRUCTEUR
3628800
Appel via ORDINAIRE
pomme instanceof Fruit = false
pomme instanceof Fruit = false

En JS des instructions peuvent s'exécuter en dehors d'un bloc de fonc-


tion, pour autant qu’elles soient au sein d’un élément SCRIPT.

<script type="text/javascript">
console.log("dieu est dieu".toUpperCase())
</script>

Affiche :

DIEU EST DIEU

Ces instructions en dehors d'une fonctions sont exécutées sans trigger, au


temps de chargement de la page Web / document HTML, et peuvent ser-
vir par exemple pour des annonces ou à aménager / initialiser certaines
situations lors du chargement de la page.

Les fonctions regroupent dans un même bloc fonctionnel compact un lot


d'instructions (code) et de variables (données) obligatoirement à exécuter
au cours d'une même demande (appel à la fonction) en respectant la
règle du flux.

Syntaxe minimale d'une déclaration de fonction :

function id_fct(){}

DIASOLUKA Nz. Luyalu -14/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
Pour qu'une fonction s'exécute elle doit être appelée (invoquée) explici-
tement ou par un event (événement : la fonction devient alors event
handler = callback) et son bloc doit préalablement être entré/pénétré,
alors se crée son « Environnement Lexical » qui englobe ses instructions
et données. À la sortie du bloc de fonction l'environnement lexical de la
fonction est généralement détruit y compris ses instructions et variables
LOCALES (sauf si cette fonction retourne une autre fonction [imbri-
quée], dans lequel cas l'environnement lexical de la fonction englobante
est conservé, la fonction imbriquée retournée par la fonction englobante
gardant un lien vers l'environnement lexical de cette fonction qui la con-
tient, donc dans laquelle elle a été déclarée/définie). L'Environnement
Lexical est une zone-mémoire allouée (réservée) au code et aux données
de la fonction.

function id_fct(paramètres){}

Une fonction non-inline ne peut s'exécuter sans appel explicite.

// Définition de la fonction
function id_fct([paramètres]){}

// Appel à la fonction
id_fct([arguments]);

Exemple :

<script type="text/javascript">
// Définition de la fonction
function id_fct(){
console.log("dieu est transcen-
dant".toUpperCase().split(""))
}

// Appel à la fonction
DIASOLUKA Nz. Luyalu -15/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
id_fct();
</script>

Exécution Avec Internet explorer 10.0.9200.17607 :

DIEU,EST,TRANSCENDANT

Exécution Avec Baidu 43.23.1008.601 :

["DIEU", "EST", "TRANSCENDANT"]

Exécution (Opéra 44.0.2510.1218 (PGO) et Yandex 17.10.1.1204)

Array(3)
0: "DIEU"
1: "EST"
2: "TRANSCENDANT"
length: 3
__proto__: Array(0)

Avec FIREFOX :

Array [ "DIEU", "EST", "TRANSCENDANT" ]

XI. Gestions de paramètres et nom de fonctions :

DIASOLUKA Nz. Luyalu -16/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
La propriété function.name (lecture seule) renvoie le nom de la fonc-
tion courante utilisée dans une instruction de fonction, ou "anony-
mous" (si elle a été créée de façon anonyme).

<script type="text/javascript"> "use strict";


function f(){
console.log("f() a reçu", arguments.length, "args:")
for(var i in arguments) console.log(i, arguments[i])
}
f(1,[],{},"texte",true);
// f() a reçu 5 arguments dont:
// 0 1 , 1 Array [] , 2 Object { } , 3 texte , 4 true

let f1=function(p,q,r,s,t,u){
}
console.log("f1() attend",f1.length,"arguments =\
nombre de paramètres formellement déclarés.");
// f1() attend 6 arguments =
// nombre de paramètres formellement déclarés.

console.log("f1.name=",f1.name); // f1.name= f1
// utilisée dans une instruction de fonction.

f1.displayName="nom_f1";
console.log("f1.name=",f1.name); // f1.name= f1
console.log("f1.displayName=",f1.displayName);
// f1.displayName= nom_f1

// Fonctions créées avec un constructeur


let f3 = Function();
console.log("f3.name=",f3.name); // f3.name= anonymous

let f4 = new Function();


console.log("f4.name=",f4.name); // f4.name= anonymous

console.log((new Function).name); // anonymous

// Fonction anonyme retournée


let f2 = function(){
return function(){};
}
DIASOLUKA Nz. Luyalu -17/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
const c=f2();
console.log("c.name=",c.name); // c.name=

var objet = {
uneMéthode1: function() {}, // anonyme
uneMéthode2: function objet_maMéthode() {}
};
console.log(objet.uneMéthode1.name); // uneMéthode1
console.log(objet.uneMéthode2.name); // objet_maMéthode
</script>

« fn . length » n'inclue pas les paramètres du reste et ne compte que les


paramètres situés avant le premier paramètre avec valeur par défaut.
Ne pas confondre non plus fn.length (nb de params attendus) et argu-
ments.length (nbre d'arguments réellement passés à la fonction) qui
aussi est locale à la fonction.

<script type="text/javascript"> // "use strict";


let f1=function(p,q,r,s,t,...u){}
let f2=function(p,q,r=5,s,t,u){}

console.log("f1() attend",f1.length,"arguments.");
// f1() attend 5 arguments.

console.log("f2() attend",f2.length,"arguments.");
// f2() attend 2 arguments.

f2(1,2);
console.log("f2.arguments=",f2.arguments);
// f2.arguments= null
</script>

Paramètre par défaut et paramètres du reste :

PARAMÈTRE PAR DÉFAUT : Valeur par défaut que prend un para-


mètre quand l’argument lui associé (argument correspondant) ne lui a
pas été envoyé ou est undefnied.

Appel d’une
DIASOLUKA Nz. Luyalu -18/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
Sans paramètres par défaut (ou paramètres initialisés) :
<script type="text/javascript">
E = Math.E; // Le mode strict déclaré plus loin

"use strict";
// Activation mode strict, n’affecte pas E.

// function f(p=5) { "use strict";


// SyntaxError: "use strict" not allowed
// in function with default parameter
// test.html:8:23

function f(p) { // Paramètre simple.


const PI=Math.PI;
console.log(`${E} & ${PI} & ${p}`)
}
f(5); // Appel de la fonction avec argument.
</script>

2.718281828459045 & 3.141592653589793 & 5 test.html:12:9

Avec paramètre par défaut (initialisé), mais en mode standard !


N.B.: L’argument d’appel d’une fonction écrase la valeur par défaut du
paramètre formel de la fonction appelée.

<script type="text/javascript">
E = Math.E; // mode strict déclaré après
"use strict";

function f(p = (a)=>{


// use strict n'a pas eu d'effet sur with
// à l'intérieur de cette fonction.
with(i in a){
console.log(`${i} "VRAI DUMMY"`);
// Le paramètre par défaut p()
// n'exécutera jamais.
}
}) {
c = 0; // use strict sans effet ici aussi.

DIASOLUKA Nz. Luyalu -19/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
const PI=Math.PI;
console.log(`${++c}. ${E}`);
console.log(`${++c}. ${PI}`);
console.log(`${++c}. *** ${ p} ***`)
console.log(`${"=".repeat(10)}`)
}

f([5 , [1,"txt",{}] , "Bull"]);


// Argument écrase paramètre par défaut.

f(); // Paramètre par défaut sera utilisé.


</script>

Un paramètre par défaut est celui qui est TOUJOURS pris en considéra-
tion avec la valeur lui définie quand la fonction appelante ne lui a pas
envoyé l’argument correspondant, mais prend éventuellement la valeur
de l’argument lui envoyé par la fonction appelante .

<script type="text/javascript"> "use strict";


function ard(n,p=2){
return
Math.floor(((n*Math.pow(10,p+1))+5)/10)/Math.pow(10,p)
DIASOLUKA Nz. Luyalu -20/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
}
console.log(ard(Math.PI)); // 3.14
console.log(ard(Math.PI,2)); // 3.14
console.log(ard(Math.PI,0)); // 3
console.log(ard(Math.PI,-1)); // 0
console.log(ard(Math.PI,5)); // 3.14159
console.log((Math.PI).toFixed(5)); // 3.14159
console.log(ard(Math.PI,Math.E)); // 3.1411691558523307
console.log((Math.PI).toFixed(Math.E)) // 3.14
</script>

Paramètre par défaut : pas supporté par les anciens navigateurs :

Opera 12 :
[10/02/2018 09:44:14] JavaScript - file://localhost/K:/test.html
Inline script compilation
Syntax error at line 2 while loading: expected ')', got '='
function ard(n,p=2){
-----------------^

Acoo Browser Version 1.98 build 744 Unicode 2008 :


Ligne: 2
Car: 18
Erreur: ')' attendu
Code: 0
URL: file:///K:/test.html

Maelstrom Version 37.0.2.1 (5920655) 2018 :


Uncaught SyntaxError: Unexpected token = test.html:2

PARAMÈTRE DU RESTE : Paramètre qui regroupe en son sein dans


une array (tableau) TOUS les derniers arguments qui ne bénéficient pas
d’un paramètre correspondant individuel.

<script type="text/javascript"> "use strict";


function multiplier(facteur=17, ...lesArgs) {
return lesArgs.map(x => facteur * x);
DIASOLUKA Nz. Luyalu -21/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
}

var arr = multiplier(7, 1, 2, 3, 4, 5);


console.log(arr); // Array [ 7, 14, 21, 28, 35 ]

var arr = multiplier(undefined, 3 , 5, 7);


console.log(arr); // Array [ 51, 85, 119 ]
</script>

« fn . name » est readonly :

<script type="text/javascript"> "use strict";


var objet = {
// anonyme
uneMéthode: function() {}
};

console.log(objet.uneMéthode.name); // uneMéthode
try{objet.uneMéthode.name = 'nvnom'}
catch(e) {console.log(e)};
// TypeError: "name" is read-only
objet.uneMéthode.name = 'nvnom';
// TypeError: "name" is read-only
</script>

CHAPITRE 7 : async function dans JavaScript

La déclaration async function définit une fonction asynchrone. Celle-


ci renvoie un objet AsyncFunction.

Exemple :

<script type="text/javascript"> "use strict";


function ftimeout(x){
setTimeout(() => {
DIASOLUKA Nz. Luyalu -22/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
console.log(x,' resolved'); // ftimeout resolved
}, 5000);
return "retour de ftimeout()"
}

function resAftdel(x) {
return new Promise(resolve => {
setTimeout(() => {
resolve(x+' resolved');
}, 5000);
});
}

async function asyncCall() {


console.log('calling'); // calling
var result = await resAftdel("asyncCall");
console.log(result); // asyncCall resolved
}

let ft=ftimeout;
console.log(ft("ftimeout")); // retour de ftimeout()

let fa=asyncCall();
console.log(fa); // Promise { <state>: "pending" }

// OUTPUT
// 13:09:02.310 test.html:24 -> retour de ftimeout()
// 13:09:02.317 test.html:18 -> calling
// 13:09:02.318 test.html:27 -> Promise {<pending>}
// 13:09:07.311 test.html:4 -> ftimeout resolved
// 13:09:07.319 test.html:20 -> asyncCall resolved
</script>

Deux autres méthodes permettent de définir des fonctions asynchrones :


le constructeur AsyncFunction et l’expression de fonction asynchrone.

Expression de fonction asynchrone :

DIASOLUKA Nz. Luyalu -23/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
<script type="text/javascript"> "use strict";
function ftimeout(x){
setTimeout(() => {
console.log(x,' resolved'); // ftimeout resolved
}, 15000);
return "retour de ftimeout()"
}

function resAftdel(x) {
return new Promise(resolve => {
setTimeout(() => {
resolve(x+' resolved');
}, 10000);
});
}

// Expression de fonction asynchrone


let asyncCall = async function(){
console.log('calling'); // calling
var result = await resAftdel("asyncCall");
console.log(result); // asyncCall resolved
}

let ft=ftimeout;
console.log(ft("ftimeout")); // retour de ftimeout()

let fa=asyncCall();
console.log(fa); // Promise { <state>: "pending" }

/* OUTPUT avec YANDEX


18:19:11.691 test.html:25 -> retour de ftimeout()
18:19:11.705 test.html:19 -> calling
18:19:11.706 test.html:28 -> Promise {[[PromiseSta-
tus]]: "pending", [[PromiseValue]]: undefined}
1 Prom-
ise {[[PromiseStatus]]: "pending", [[PromiseValue]]
: undefined}
A __proto__:Promise
1 catch:ƒ catch()
2 constructor:ƒ Promise()
DIASOLUKA Nz. Luyalu -24/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
3 finally:ƒ finally()
4 then:ƒ then()
5 Symbol(Symbol.toStringTag):"Promise"
6 __proto__:Object
B [[PromiseStatus]]:"resolved"
C [[PromiseValue]]:undefined
18:19:21.862 test.html:21 -> asyncCall resolved
18:19:26.696 test.html:4 -> ftimeout resolved */

Syntaxe :

async function name([param[, param[, ... param]]]) {


instructions
}

Valeur de retour :

Un objet AsyncFunction qui représente une fonction asynchrone qui


exécute le code contenu dans la fonction.

Lorsqu'une fonction asynchrone est appelée, elle renvoie une promesse


(promise).
Lorsque la fonction asynchrone renvoie une valeur, la promesse est ré-
solue avec la valeur renvoyée.
Lorsque la fonction asynchrone lève une exception, la promesse est
rompue avec la valeur de l'exception.

Notez ci-dessous que Promise n’est pas explicitement définie.

<script type="text/javascript"> "use strict";


function resAftdel(x) {}

// Expression de fonction asynchrone


let asyncCall = async function(){
console.log('calling'); // calling
var result = await resAftdel("asyncCall");

DIASOLUKA Nz. Luyalu -25/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
console.log(result); // asyncCall resolved
}

console.log(asyncCall()); // Promise { <state>:


"pending" }
// Note: Promise n’est pas explicitement définie.

/* OUTPUT avec FIREFOX


calling test.html:11:3
Promise { <state>: "pending" } test.html:16:1
Promise { "pending" }
<state>: "pending"
__proto__: PromiseProto
catch: function catch()
constructor: function Promise()
all: function all()
length: 1
name: "Promise"
prototype: PromiseProto { … }
catch: function catch()
constructor: function Promise()
finally: function finally()
then: function then()
Symbol(Symbol.toStringTag): undefined
__proto__: Object { … }
race: function race()
reject: function reject()
resolve: function resolve()
Symbol(Symbol.species): undefined
__proto__: function ()
finally: function finally()
then: function then()
Symbol(Symbol.toStringTag): undefined
__proto__: Object { … }
undefined test.html:13:3

OUTPUT avec YANDEX


23:46:11.555 test.html:11 calling
23:46:11.559 test.html:16 Promise {[[PromiseStatus]]:
"pending", [[PromiseValue]]: undefined}__proto__:
DIASOLUKA Nz. Luyalu -26/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
Promise[[PromiseStatus]]: "resolved"[[PromiseValue]]:
undefined
Prom-
ise {[[PromiseStatus]]: "pending", [[PromiseValue]]:
undefined}
A __proto__:Promise
I catch:ƒ catch()
II constructor:ƒ Promise()
a all:ƒ all()
b arguments:(...)
c caller:(...)
d length:1
e name:"Promise"
f proto-
type:Promise {Symbol(Symbol.toStringTag): "P
romise", constructor: ƒ, then: ƒ, catch: ƒ}
g race:ƒ race()
h reject:ƒ reject()
i resolve:ƒ resolve()
j Symbol(Symbol.species):(...)
k get Sym-
bol(Symbol.species):ƒ [Symbol.species]()
l __proto__:ƒ ()
m [[Scopes]]:Scopes[0]
I then:ƒ then()
II Symbol(Symbol.toStringTag):"Promise"
III __proto__:Object
A [[PromiseStatus]]:"resolved"
B [[PromiseValue]]:undefined
23:46:11.561 test.html:13 undefined */
</script>

Avec Promise explicitement définie :

<script type="text/javascript"> "use strict";


function resAftdel(x) {
return new Promise(resolve => {
setTimeout(() =>
resolve(x+' resolved') , 10000);

DIASOLUKA Nz. Luyalu -27/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
});
}

// Expression de fonction asynchrone


let asyncCall = async function(){
console.log('calling'); // calling
var result = await resAftdel("asyncCall");
console.log(result); // asyncCall resolved
}

console.log(asyncCall()); // Promise { <state>:


"pending" }

/* OUTPUT
00:12:53.250 test.html:11 -> calling
00:12:53.254 test.html:16 -> Promise {[[PromiseSta-
tus]]: "pending", [[PromiseValue]]: undefined}
00:13:03.255 test.html:13 -> asyncCall resolved */
</script>

Une expression await permet à une fonction asynchrone d'interrompre


son exécution en attendant la résolution d'une promesse passée à l'ex-
pression. La fonction asynchrone poursuit son exécution quand la pro-
messe est résolue.

<script type="text/javascript"> "use strict";


const arg=10,delay=10000;
function resAftdel(x) {
console.log("Dans resAftdel()");
return new Promise(resolve => {
setTimeout(() => {
resolve(x);
}, delay);
});
}

// Ici, await la fonction appelée

async function add1(x) {


DIASOLUKA Nz. Luyalu -28/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
console.log(x,typeof x);
const a = await resAftdel(20);
console.log(a,typeof a);
const b = await resAftdel(30);
console.log(b,typeof b);
// b=... doit attendre la fin de a=...

return x + a + b;
}

// Appel normal, Affiche promise.


console.log(add1(arg));

// Pour afficher la valeur retournée par add1() :


// On exécute la fonction async, puis (then)...
// ici fonction fléchée

add1(arg).then(v => { console.log(v); });


// v est le résultat retourné par add1
// Affiche le résultat, à l'expiration du delai.

// Ici, await l'initialiation de la variable

async function add2(x) {


const a = resAftdel(20);
const b = resAftdel(30);

return x + await a + await b;


// await a et await b attendent concurrenciellement
}

add2(arg).then(v => { console.log(v); });


// v est le résultat retourné par add2
// Affiche le résultat, à l'expiration du delai.

// OUTPUT
// 12:48:53.071 test.html:15 -> 10 "number"
// 12:48:53.075 test.html:4 -> Dans resAftdel()
// 12:48:53.076 test.html:26 -> Promise {<pending>}
// 12:48:53.079 test.html:15 -> 10 "number"
DIASOLUKA Nz. Luyalu -29/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
// 12:48:53.080 test.html:4 -> Dans resAftdel()
// 12:48:53.080 test.html:4 -> Dans resAftdel()
// 12:48:53.080 test.html:4 -> Dans resAftdel()
// 12:49:03.076 test.html:17 -> 20 "number"
// 12:49:03.076 test.html:4 -> Dans resAftdel()
// 12:49:03.081 test.html:17 -> 20 "number"
// 12:49:03.081 test.html:4 -> Dans resAftdel()
// 12:49:03.082 test.html:46 -> 60
// 12:49:13.077 test.html:19 -> 30 "number"
// 12:49:13.082 test.html:19 -> 30 "number"
// 12:49:13.082 test.html:32 -> 60
</script>

Ne confondez pas await et Promise.all(). Les appels à await sont exécu-


tés en série et pas en parallèle, contrairement à Promise.all() qui exécute
plusieurs promesses en parallèle.

Anatomie de la fonction Promise() à la console :

>Promise
function Promise()
Promise()
length: 1
name: "Promise"
prototype: PromiseProto
catch: function catch()
constructor: Promise()
length: 1
name: "Promise"
prototype: PromiseProto
catch: function catch()
constructor: Promise()
length: 1
name: "Promise"
prototype: PromiseProto { … }
race: function race()
reject: function reject()
resolve: function resolve()
Symbol(Symbol.species): undefined
DIASOLUKA Nz. Luyalu -30/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
__proto__: function ()
then: function then()
Symbol(Symbol.toStringTag): undefined
__proto__: Object { … }
race: function race()
reject: function reject()
resolve: function resolve()
Symbol(Symbol.species): undefined
__proto__: function ()
then: function then()
Symbol(Symbol.toStringTag): undefined
__proto__: Object { … }
race: function race()
reject: function reject()
resolve: function resolve()
Symbol(Symbol.species): undefined
__proto__: function ()

Et les propriétés propres de Promise :

Object.getOwnPropertyNames(Promise)
Array [ "all", "race", "reject", "resolve", "proto-
type", "length", "name" ]

Et les descripteurs de propriétés propres de Promise :

Object.getOwnPropertyDescriptors(Promise)
Object { all: {…}, race: {…}, reject: {…}, resolve: {…},
prototype: {…}, length: {…}, name: {…}, Sym-
bol(Symbol.species): {…} }
{…}
all: Object { writable: true, enumerable: false, config-
urable: true, … }
length: Object { value: 1, writable: false, enumerable:
false, … }
name: Object { value: "Promise", writable: false, enu-
merable: false, … }
prototype: Object { writable: false, enumerable: false,
configurable: false, … }
DIASOLUKA Nz. Luyalu -31/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
race: Object { writable: true, enumerable: false, con-
figurable: true, … }
reject: Object { writable: true, enumerable: false, con-
figurable: true, … }
resolve: Object { writable: true, enumerable: false,
configurable: true, … }
Symbol(Symbol.species): Object { get: get [Sym-
bol.species](), enumerable: false, configurable: true, … }
__proto__: Object { … }

CHAPITRE 8 : Les OPÉRATEURS dans JavaScript

JavaScript comporte une gamme complète d’opérateurs (arithmétiques,


logiques, bitwise, d’affectation (assignment), et autres.

I. Computational Operators

Description Symbol
Unary negation -
Increment ++
Decrement --
Multiplication *
Division /
Modulus arithmetic %
Addition +
Subtraction -

II. Logical Operators

Description Symbol
Logical NOT !
Less than <
Greater than >
Less than or equal to <=
Greater than or equal to >=
DIASOLUKA Nz. Luyalu -32/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
Description Symbol
Equality ==
Inequality !=
Logical AND &&
Logical OR ||
Conditional (ternary) ?:
Comma ,
Strict Equality ===
Strict Inequality !==

III. Bitwise Operators

Description Symbol
Bitwise NOT ~
Bitwise Left Shift <<
Bitwise Right Shift >>
Unsigned Right Shift >>>
Bitwise AND &
Bitwise XOR ^
Bitwise OR |

IV. Assignment Operators

Description Symbol
Assignment =
OP= (such as +=
Compound Assignment
and &=)

V. Miscellaneous Operators

Description Symbol
delete Delete
typeof typeof
DIASOLUKA Nz. Luyalu -33/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
Description Symbol
void Void
instanceof instanceof
new New
in In

VI. Equality and Strict Equality

L’opérateur d’égalité == (equality) coerce (transtype) les valeurs des


différents types avant la comparaison ("1" == 1), tandis que l’opérateur
d’égalité stricte === (strict equality) les compare comme telles ("1" !==
1).

Les valeurs primitives (strings, numbers, Booleans) sont comparées par


les valeurs qu’elles renferment, qu’elles représentent. Si deux variables
renferment la même valeur, elles sont considérées comme égales.

Les objets (Array, Function, String, Number, Boolean, Error, Date et


RegExp objects) sont plutôt des références (pointeurs) ; elles renferment
l’adresse de (pointent) la donnée. Ils sont comparés par référence (c’est
la valeur contenue à l’adresse-mémoire pointée qui est comparée). Si les
valeurs ainsi pointées sont égales, alors les deux objets sont égaux.

<script type="text/javascript"> "use strict";


var k=7, m=7;
console.log(k==m); // true
console.log(k===m); // true
var p=new String("7"), q=new String("7");
console.log(p==q); // false
console.log(p===q); // false
console.log(p.valueOf()==q.valueOf()); // true
console.log(p.valueOf()===q.valueOf()); // true
console.log(p.toString()==q.toString()); // true
console.log(p.toString()===q.toString()); // true
console.log(String(p)==String(q)); // true
console.log(String(p)===String(q)); // true
</script>

DIASOLUKA Nz. Luyalu -34/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions

Opérateurs modulo, égalité, ... avec les Nombres d’Armstrong :

<script type="text/javascript"> "use strict";


function sr(t){
var cpt=0,mp,exp=11
console.log(t.toExponential(2)) // 1.00e+9
for(var p=0;p<=t;p++){
let m=0,r=0,n=p,ps=String(p)
/* for(var te=0,l=ps.length;te<l;)
if(Math.pow(ps.charAt(te++),exp)>t)continue; */
for(var k=0,l=Math.log10(n);k<=l;k++){
m=n%10
if((mp=Math.pow(m,exp))>t) {
// console.log(p+") "+mp.toExponential(2))
break // Nb svt, p.e. de 999 à 1000
}
n=(n-m)/10
r+=mp;
}
if(r==p)console.log(++cpt+") p="+p+", r="+r+" = N
d'Armstrong"+exp)
// 1) p=0, r=0 = N d'Armstrong3
// 2) p=1, r=1 = N d'Armstrong3
// 3) p=153, r=153 = N d'Armstrong3
// 4) p=370, r=370 = N d'Armstrong3
// 5) p=371, r=371 = N d'Armstrong3
// 6) p=407, r=407 = N d'Armstrong3
}
}
sr(1e9)
</script>

Pas un seul nombre d’Armstrong3 de 408 à 1e9 !

Ce qui est plus choquant, c’est qu’il n’y a aucun nombre d’Armstrong
(sauf le 0 et le 1) avec l’exposant 2, jusqu’à 1e9 :

1) p=0, r=0 = N d'Armstrong2

DIASOLUKA Nz. Luyalu -35/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
2) p=1, r=1 = N d'Armstrong2

Si au lieu du cube des chiffres constitutifs du nombre on les élève à


l’exposants 4 (il suffit de modifier la ligne 9), on obtient les nombres
d’Armstrong à l’exposant 4 suivants, entre 1 et 1e9 :

1) p=0, r=0 = N d'Armstrong4


2) p=1, r=1 = N d'Armstrong4
3) p=1634, r=1634 = N d'Armstrong4
4) p=8208, r=8208 = N d'Armstrong4
5) p=9474, r=9474 = N d'Armstrong4

Si au lieu de l’exposant 4 on utilise l’exposant 5, on obtient les nombres


d’Armstrong à l’exposant 5 suivants, entre 1 et 1e9 :

1) p=0, r=0 = N d'Armstrong5


2) p=1, r=1 = N d'Armstrong5
3) p=4150, r=4150 = N d'Armstrong5
4) p=4151, r=4151 = N d'Armstrong5
5) p=54748, r=54748 = N d'Armstrong5
6) p=92727, r=92727 = N d'Armstrong5
7) p=93084, r=93084 = N d'Armstrong5
8) p=194979, r=194979 = N d'Armstrong5

Avec l’exposant 6, un seul nombre d’Armstrong outre le 0 et 1 :

1) p=0, r=0 = N d'Armstrong6


2) p=1, r=1 = N d'Armstrong6
3) p=548834, r=548834 = N d'Armstrong6

Avec l’exposant 7, on obtient les nombres d’Armstrong suivants :

1) p=0, r=0 = N d'Armstrong7


2) p=1, r=1 = N d'Armstrong7
3) p=1741725, r=1741725 = N d'Armstrong7
4) p=4210818, r=4210818 = N d'Armstrong7

DIASOLUKA Nz. Luyalu -36/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
5) p=9800817, r=9800817 = N d'Armstrong7
6) p=9926315, r=9926315 = N d'Armstrong7
7) p=14459929, r=14459929 = N d'Armstrong7

Avec l’exposant 8, on obtient les nombres d’Armstrong suivants :

1) p=0, r=0 = N d'Armstrong8


2) p=1, r=1 = N d'Armstrong8
3) p=24678050, r=24678050 = N d'Armstrong8
4) p=24678051, r=24678051 = N d'Armstrong8
5) p=88593477, r=88593477 = N d'Armstrong8

Avec l’exposant 9, on obtient les nombres d’Armstrong suivants :

1) p=0, r=0 = N d'Armstrong9


2) p=1, r=1 = N d'Armstrong9
3) p=146511208, r=146511208 = N d'Armstrong9
4) p=472335975, r=472335975 = N d'Armstrong9
5) p=534494836, r=534494836 = N d'Armstrong9
6) p=912985153, r=912985153 = N d'Armstrong9

Avec exp >10 pour 1e9, aucun nombre d’Armstrong outre le 0 et le 1 :

1) p=0, r=0 = N d'Armstrong10


2) p=1, r=1 = N d'Armstrong10

Sinus d’un angle avec Formule de Taylor :

<script type="text/javascript"> "use strict";


function sin(a,n){
var cpt=0, s, r=0
console.log("sin "+a+" s. de Taylor "+-(-n-1)+" terms")
for(var p=0;p<=n;p++){
r+=Math.pow(-1,p)*Math.pow(a,2*p+1)/fact(2*p+1)
s=Math.sin(a)

DIASOLUKA Nz. Luyalu -37/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
}
console.log("r = "+r)
console.log("Math.sin = "+s)
if(r==s)console.log("r="+r+" = Math.sin = "+s)
else console.log("D = "+eval(r-s))
// sinus 10 série de Taylor -> n=153
// r = -0.5440211108892695
// Math.sin = -0.5440211108893698
// D = 1.0025313912365164e-13
}
sin(10,153)

function fact(n) {
if (n == 0) return 1;
else return fact(n-1)*n ; }
</script>

CHAPITRE 9 : La FONCTION setInterval(fct,del) dans JS

<div id="idiv" style="width:200;height:60"></div>


<script type="text/javascript"> "use strict";
function timeLaps() {
// The timeLaps() constructor defines `this`
// as an instance of itself.
var that=this;
// pointeur that = alias de this, mais
// n'est pas traité (reconnu, référencé) de la même
// façon que le mot-clé this.
// On peut utiliser n’importe quel nom de variable
// autorisé à la place de that ;
// essayez par exemple voglo à la place de that.

that.gb = "Hey, you";


that.delay=5000;

let t=setTimeout(function () {
// In non-strict mode, the function defines `this`
// as the global object, which is different from
// the `this` defined by the timeLaps() constructor.
document.getElementById('idiv').innerText=
DIASOLUKA Nz. Luyalu -38/42- JavaScript T.-III
Gestions de paramètres et noms de fonctions
that.gb +" "+ that.delay/1000 + " secs past";
if(that.secs>=10)clearTimeout(t);
}, this.delay);
}

var p = new timeLaps();


</script>
// Hey, you 5 secs past

DIASOLUKA Nz. Luyalu -39/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions

Kinshasa, le dimanche 24 mars 2019 - 9:22:29 AM

Mots-clés :
JAVASCRIPT, Programmation Internet, fonction de haut rang,
High Order Function, keys, values, parseInt, parseFloat, toString,
récursion, fichier externe, bibliothèques, frameworks, fonction flé-
chée, sloppy mode, mode strict, prototype, objet ordinaire, objet
exotique, objet standard, built-in object, Scope, contexte
d’exécution, Domaine, Portée, Étendue, Visibilité, Accessibilité,
durée de vie, Es10, ECMASCRIPT 2019, LiveScript, extra-
dimensionnels, entités éthériques non-biologiques, TC39, ECMA,
Kaprekar

DIASOLUKA Nz. Luyalu


Docteur en Médecine, Chirurgie & Accouchements (1977),
CNOM : 0866 - Spécialiste en ophtalmologie (1980)
Études humanités : Scientifique - Mathématiques & Physique.
Informaticien-amateur, Programmeur et WebMaster.
Chercheur indépendant, autonome et autofinancé, bénévole, sans
aucun conflit d’intérêt ou liens d'intérêts ou contrainte promotionnelle
avec qui qu’il soit ou quelqu’organisme ou institution / organisation
que ce soit, étatique, paraétatique ou privé, industriel ou commercial
en relation avec le sujet présenté.

+243 - 851278216 - 899508675 - 991239212 - 902263541 - 813572818

diasfb@mail2world.com

DIASOLUKA Nz. Luyalu -40/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions

Autre Lecture :
https://www.scribd.com/document/374738470/Le-Plus-Grand-Secret-de-La-
Creation

D’autres publications pouvant aussi intéresser :

• https://www.scribd.com/document/377036251/Le-Dosage-Des-
Medicaments-en-Cac-Cas
• https://www.scribd.com/document/377035454/Le-Hasard-Des-
Thermometres-Non-contact-a-Infrarouge
• https://www.scribd.com/document/376222482/Petite-Introduction-
Aux-Fonctions-JavaScript
• https://www.scribd.com/document/376221919/La-Foi-en-Jesus-Christ-
Pour-Quoi-Faire
• https://www.scribd.com/document/375689778/Lacuite-visuelle-
angulaire
• https://www.scribd.com/document/375349851/La-variable-This
• https://www.scribd.com/document/375024162/Fonctions-Imbriquees-
en-JS
• https://www.scribd.com/document/374789297/Format-Interne-Des-
Objets-JavaScript
• https://www.scribd.com/document/374788758/Iterations-en-JavaScript
• https://www.scribd.com/document/374738470/Le-Plus-Grand-Secret-
de-La-Creation
• https://www.scribd.com/document/374597969/Nouvelle-Formule-d-
IMC-indice-de-doduite-Selon-Dr-Diasoluka
• https://www.scribd.com/document/373847209/Property-Descriptors
• https://www.scribd.com/document/373833282/l-Objet-Global-Window
• https://www.scribd.com/document/372665249/Javascript-Tome-II
• https://www.scribd.com/document/355291488/motilite-oculaire-2
• https://www.scribd.com/document/355291239/motilite-oculaire-I
• https://www.scribd.com/document/355290248/Script-d-Analyses-Des-

DIASOLUKA Nz. Luyalu -41/42- JavaScript T.-III


Gestions de paramètres et noms de fonctions
Reflexes-Pupillomoteurs
• https://www.scribd.com/document/321168468/Renseignements-Id-et-
Anthropometriques
• https://www.scribd.com/document/320856721/Emission-31-Jul-2016
• https://www.scribd.com/document/318182982/Complication-Visuelle-
du-Traitement-de-La-Malaria
• https://www.scribd.com/document/318180637/Rapport-Entre-
Oxymetrie-Et-Type-Respiration
• https://www.scribd.com/document/315746265/Classification-Des-
Medicaments
• https://www.scribd.com/document/315745909/Incongruences-
Heresies-et-Heterodoxies-de-la-Notion-de-Laboratoire
• https://www.scribd.com/document/315745725/Rapport-Entre-
Oxymetrie-Et-Type-Respiration

DIASOLUKA Nz. Luyalu -42/42- JavaScript T.-III