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

Gestions
noms
de
de
paramètres
fonctions
et
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 appelée « sous-programme ») que le navigateur interprète comme instructions 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 fonctionnement interne (y compris ses paramètres, son unique valeur 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 terminales.
Des fonctions peuvent être prédéfinies dans le navigateur ou le compilateur (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 parenthè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 paramè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 retourne (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 factorielle 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écursives), 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. */
/* I.3. */
</script>
var fob = function(){}; // Affectée.
var foc = () => {}; // Fléchée.
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
A
B
C
D
E
F
b.
, prototype: {…}}
arguments:{value: null, writable: false, enumerable: fals
e, configurable: false}
caller:{value: null, writable: false, enumerable: false,
configurable: false}
length:{value: 1, writable: false, enumerable: false,
configurable: true}
name:{value: "foo", writable: false, enumerable: fals
e, configurable: true}
prototype:{value: {…}, writable: true, enumerable: false,
configurable: false}
__proto__:Object
Object.getOwnPropertyDescriptors(fob)
1er
{length: {…}, name: {…}, arguments: {…}, caller: {…}
, prototype: {…}}
A
arguments:{value: null, writable: false, enumerable: fals
e, configurable: false}
B
caller:{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
prototype:{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. */
/* II.2. */
(function(){})(); // Inline.
!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
arguDIASOLUKA Nz. Luyalu
-5/42JavaScript T.-III
Gestions de paramètres et noms de fonctions
B
C
D
E
F
ments:{value: null, writable: false, enumerable: fals
e, configurable: false}
caller:{value: null, writable: false, enumerable: false,
configurable: false}
length:{value: 2, writable: false, enumerable: false,
configurable: true}
name:{value: "", writable: false, enumerable: false,
configurable: true}
prototype:{value: {…}, writable: true, enumerable: false,
configurable: false}
__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
(<anonymous>)
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 fonction (sauf quand il s’agit de fonction anonyme) suivi d’une paire de parenthè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, plutô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 identifiants 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)
12.352855437858855 ans.
this.html:17
this.html:18
Déf. : Un argument d’une fonction est un paramètre passé à la fonction 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 position (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 utilisé 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 (variables 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 imbriqué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 objetproprié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 soitelle est donc ni plus ni moins un[e instance d’] objet un « callable object » (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 fonction, 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 servir 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) explicitement 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 [imbriqué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 contient, 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 transcendant".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 fonction courante utilisée dans une instruction de fonction, ou "anonymous" (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 arguments.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 paramè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ération 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. Celleci 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
// 13:09:02.317
// 13:09:02.318
// 13:09:07.311
// 13:09:07.319
</script>
test.html:24
test.html:18
test.html:27
test.html:4
test.html:20
->
->
->
->
->
retour de ftimeout()
calling
Promise {<pending>}
ftimeout resolved
asyncCall resolved
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 {[[PromiseStatus]]: "pending", [[PromiseValue]]: undefined}
1 Promise {[[PromiseStatus]]: "pending", [[PromiseValue]]
: undefined}
A
__proto__:Promise
1 catch:ƒ catch()
2 constructor:ƒ Promise()
DIASOLUKA Nz. Luyalu
-24/42JavaScript 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/42JavaScript T.-III
Gestions de paramètres et noms de fonctions
Promise[[PromiseStatus]]: "resolved"[[PromiseValue]]:
undefined
Promise {[[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
prototype:Promise {Symbol(Symbol.toStringTag): "P
romise", constructor: ƒ, then: ƒ, catch: ƒ}
g
race:ƒ race()
h
reject:ƒ reject()
i
resolve:ƒ resolve()
j
Symbol(Symbol.species):(...)
k
get Symbol(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 {[[PromiseStatus]]: "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'expression. La fonction asynchrone poursuit son exécution quand la promesse 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/42JavaScript T.-III
Gestions de paramètres et noms de fonctions
// 12:48:53.080
// 12:48:53.080
// 12:48:53.080
// 12:49:03.076
// 12:49:03.076
// 12:49:03.081
// 12:49:03.081
// 12:49:03.082
// 12:49:13.077
// 12:49:13.082
// 12:49:13.082
</script>
test.html:4
test.html:4
test.html:4
test.html:17
test.html:4
test.html:17
test.html:4
test.html:46
test.html:19
test.html:19
test.html:32
->
->
->
->
->
->
->
->
->
->
->
Dans resAftdel()
Dans resAftdel()
Dans resAftdel()
20 "number"
Dans resAftdel()
20 "number"
Dans resAftdel()
60
30 "number"
30 "number"
60
Ne confondez pas await et Promise.all(). Les appels à await sont exécuté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", "prototype", "length", "name" ]
Et les descripteurs de propriétés propres de Promise :
Object.getOwnPropertyDescriptors(Promise)
Object { all: {…}, race: {…}, reject: {…}, resolve: {…},
prototype: {…}, length: {…}, name: {…}, Symbol(Symbol.species): {…} }
{…}
all: Object { writable: true, enumerable: false, configurable: true, … }
length: Object { value: 1, writable: false, enumerable:
false, … }
name: Object { value: "Promise", writable: false, enumerable: 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, configurable: true, … }
reject: Object { writable: true, enumerable: false, configurable: true, … }
resolve: Object { writable: true, enumerable: false,
configurable: true, … }
Symbol(Symbol.species): Object { get: get [Symbol.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
Unary negation
Increment
Decrement
Multiplication
Division
Modulus arithmetic
Addition
Subtraction
II.
Symbol
++
-*
/
%
+
-
Logical Operators
Description
Logical NOT
Less than
Greater than
Less than or equal to
Greater than or equal to
DIASOLUKA Nz. Luyalu
Symbol
!
<
>
<=
>=
-32/42JavaScript T.-III
Gestions de paramètres et noms de fonctions
Description
Equality
Inequality
Logical AND
Logical OR
Conditional (ternary)
Comma
Strict Equality
Strict Inequality
III.
Symbol
==
!=
&&
||
?:
,
===
!==
Bitwise Operators
Description
Bitwise NOT
Bitwise Left Shift
Bitwise Right Shift
Unsigned Right Shift
Bitwise AND
Bitwise XOR
Bitwise OR
IV.
Assignment Operators
Description
Assignment
Compound Assignment
V.
Symbol
~
<<
>>
>>>
&
^
|
Symbol
=
OP= (such as +=
and &=)
Miscellaneous Operators
Description
delete
typeof
DIASOLUKA Nz. Luyalu
Symbol
Delete
typeof
-33/42-
JavaScript T.-III
Gestions de paramètres et noms de fonctions
Description
void
instanceof
new
in
VI.
Symbol
Void
instanceof
New
In
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());
//
console.log(p.valueOf()===q.valueOf());
//
console.log(p.toString()==q.toString()); //
console.log(p.toString()===q.toString()); //
console.log(String(p)==String(q));
//
console.log(String(p)===String(q));
//
</script>
DIASOLUKA Nz. Luyalu
-34/42-
true
true
true
true
true
true
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)
2)
3)
4)
5)
p=0, r=0 = N d'Armstrong4
p=1, r=1 = N d'Armstrong4
p=1634, r=1634 = N d'Armstrong4
p=8208, r=8208 = N d'Armstrong4
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)
2)
3)
4)
5)
6)
7)
8)
p=0, r=0 = N d'Armstrong5
p=1, r=1 = N d'Armstrong5
p=4150, r=4150 = N d'Armstrong5
p=4151, r=4151 = N d'Armstrong5
p=54748, r=54748 = N d'Armstrong5
p=92727, r=92727 = N d'Armstrong5
p=93084, r=93084 = N d'Armstrong5
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)
2)
3)
4)
p=0, r=0 =
p=1, r=1 =
p=1741725,
p=4210818,
N d'Armstrong7
N d'Armstrong7
r=1741725 = N d'Armstrong7
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)
2)
3)
4)
5)
p=0, r=0 = N d'Armstrong8
p=1, r=1 = N d'Armstrong8
p=24678050, r=24678050 = N d'Armstrong8
p=24678051, r=24678051 = N d'Armstrong8
p=88593477, r=88593477 = N d'Armstrong8
Avec l’exposant 9, on obtient les nombres d’Armstrong suivants :
1)
2)
3)
4)
5)
6)
p=0, r=0 = N
p=1, r=1 = N
p=146511208,
p=472335975,
p=534494836,
p=912985153,
d'Armstrong9
d'Armstrong9
r=146511208 =
r=472335975 =
r=534494836 =
r=912985153 =
N
N
N
N
d'Armstrong9
d'Armstrong9
d'Armstrong9
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/42JavaScript 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 vendredi 31 mai 2019 - 11:24:38 PM
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, extradimensionnels, 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
[email protected]
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-LaCreation
D’autres publications pouvant aussi intéresser :
• https://www.scribd.com/document/377036251/Le-Dosage-DesMedicaments-en-Cac-Cas
• https://www.scribd.com/document/377035454/Le-Hasard-DesThermometres-Non-contact-a-Infrarouge
• https://www.scribd.com/document/376222482/Petite-IntroductionAux-Fonctions-JavaScript
• https://www.scribd.com/document/376221919/La-Foi-en-Jesus-ChristPour-Quoi-Faire
• https://www.scribd.com/document/375689778/Lacuite-visuelleangulaire
• https://www.scribd.com/document/375349851/La-variable-This
• https://www.scribd.com/document/375024162/Fonctions-Imbriqueesen-JS
• https://www.scribd.com/document/374789297/Format-Interne-DesObjets-JavaScript
• https://www.scribd.com/document/374788758/Iterations-en-JavaScript
• https://www.scribd.com/document/374738470/Le-Plus-Grand-Secretde-La-Creation
• https://www.scribd.com/document/374597969/Nouvelle-Formule-dIMC-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-DesDIASOLUKA 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-etAnthropometriques
• https://www.scribd.com/document/320856721/Emission-31-Jul-2016
• https://www.scribd.com/document/318182982/Complication-Visuelledu-Traitement-de-La-Malaria
• https://www.scribd.com/document/318180637/Rapport-EntreOxymetrie-Et-Type-Respiration
• https://www.scribd.com/document/315746265/Classification-DesMedicaments
• https://www.scribd.com/document/315745909/IncongruencesHeresies-et-Heterodoxies-de-la-Notion-de-Laboratoire
• https://www.scribd.com/document/315745725/Rapport-EntreOxymetrie-Et-Type-Respiration
DIASOLUKA Nz. Luyalu
-42/42-
JavaScript T.-III