Javascript - Tome - Xxiii - Gestions de Paramètres Et Nom de Fonctions

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

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: {…}

, 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,
F __proto__:Object
b. Object.getOwnPropertyDescriptors(fob)

, prototype: {…}}
A argu-
B cal-
configurable: true}
D name:{value: "fob", writable: false, enumerable: fals
E proto-
F __proto__:Object

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
C __proto__:Object
II. Fonctions ANONYMES :
"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 ))
})

, prototype: {…}}
A argu-
B cal-
configurable: true}
D name:{value: "", writable: false, enumerable: false,
configurable: true}
E proto-
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>)

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.
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 ».
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 :

function f_date(d,m,y){
return new Date(y,m-1,d)
}
</script>
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é)
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 :
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 :
var Fruit = function(n,s){
// Variables locale
couleur= "rouge";
poids= 50;
console.log("Appel via "+s)

};
// 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

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
Ici l’instance est créé avec « new » :
couleur="jaune"
console.log("Couleur = "+couleur)
}
// Créer une instance-objet de cette fonction

pomme=new Fruit();
// Appel de la fonction Fruit via pomme

console.log(pomme.couleur);
// Appel direct de la Fruit fonction

console.log(Fruit.couleur);
////////
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 ».

2) La récursion qui calcule ici la factorielle du nombre en argument.
3) La redéfinition (écrasement) de la fonction « toString() ».
// 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"));
////////
Fruit(null , "ORDINAIRE");

</script>
Exécution :

Appel via CONSTRUCTEUR
3628800
Appel via ORDINAIRE
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.
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(){}

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 :
// Définition de la fonction
function id_fct(){
console.log("dieu est transcen-
dant".toUpperCase().split(""))
}
// Appel à la fonction
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 :

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

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(){};
}
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
Sans paramètres par défaut (ou paramètres initialisés) :
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.
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.

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 .

function ard(n,p=2){
return
Math.floor(((n*Math.pow(10,p+1))+5)/10)/Math.pow(10,p)
}
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.

function multiplier(facteur=17, ...lesArgs) {
return lesArgs.map(x => facteur * x);
}
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 :

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 :

function ftimeout(x){
setTimeout(() => {
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 :

function ftimeout(x){
setTimeout(() => {
console.log(x,' resolved'); // ftimeout resolved
}, 15000);
return "retour de ftimeout()"
}
setTimeout(() => {
resolve(x+' resolved');
}, 10000);
});
}
// Expression de fonction asynchrone

let asyncCall = async function(){
}
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()
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.

function resAftdel(x) {}


}
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 { … }
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()
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__:
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 :

setTimeout(() =>
resolve(x+' resolved') , 10000);

});
}

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

const arg=10,delay=10000;
console.log("Dans resAftdel()");
setTimeout(() => {
resolve(x);
}, delay);
});
}
// Ici, await la fonction appelée
async function add1(x) {

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"
// 12:49:03.076 test.html:17 -> 20 "number"
// 12:49:03.081 test.html:17 -> 20 "number"
// 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
constructor: Promise()
length: 1
name: "Promise"
prototype: PromiseProto
constructor: Promise()
length: 1
name: "Promise"
prototype: PromiseProto { … }
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, … }
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, … }
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 >=
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
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.

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>

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

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

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 :

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 :

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 :

3) p=548834, r=548834 = N d'Armstrong6
Avec l’exposant 7, on obtient les nombres d’Armstrong suivants :

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

5) p=9800817, r=9800817 = N d'Armstrong7
6) p=9926315, r=9926315 = N d'Armstrong7
7) p=14459929, r=14459929 = N d'Armstrong7

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

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 :

Sinus d’un angle avec Formule de Taylor :

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)

}
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>

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=
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

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

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-

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

Javascript - Tome - Xxiii - Gestions de Paramètres Et Nom de Fonctions

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Javascript - Tome - Xxiii - Gestions de Paramètres Et Nom de Fonctions

Hochgeladen von

Copyright:

Verfügbare Formate

Gestions de paramètres et

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

J.B. Dadet DIASOLUKA Luyalu Nzoyifuanga

CHAPITRE 10 : Les FONCTIONS dans JavaScript

Une fonction requiert deux conditions :

1. Elle doit être déclarée/définie. En JS

2. Elle doit par la suite être explicitement appelée. Une fonction ne

Des fonctions peuvent être prédéfinies dans le navigateur ou le compila-

On peut plus facilement comprendre un appel à une fonction comme

La définition d’une fonction est reconnaissable par une paire de paren-

Une fonction sert habituellement à effectuer une tâche répétitive, et re-

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

function nom_fonction ( arguments0, arguments1, ... argumentsN ) {

Il y a deux façons de déclarer une fonction en JS : Comme fonctions

/* I.1. */ function foo(p){ p() }; // Classique.

/* I.2. */ var fob = function(){}; // Affectée.

Voici l’architecture interne de ces fonctions, particulièrement la valeur

De fonction anonyme ou pas, les pointeurs sur fonction représentent la

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

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

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

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

II. Fonctions ANONYMES :

/* II.1. */ (function(){})(); // Inline.

/* II.3. */ function fob(){ // FCT NOMMÉE

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

Les fonctions fléchées sont TOUJOURS anonymes :

Object.getOwnPropertyDescriptors(() => {})

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

Autres fonctions anonymes :

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

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-

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

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

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

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

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

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

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

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

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

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

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

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

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

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

console.log("Appel via "+s)

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

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

// Appel de la fonction Fruit via pomme

// Appel direct de la Fruit fonction

r = pomme instanceof Fruit;

Appel via CONSTRUCTEUR

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

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

// Appel de la fonction Fruit via pomme

// Appel direct de la Fruit fonction

r = pomme instanceof Fruit;

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

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