Les fonctions en JavaScript-II

publicité
Pour Débutant
J AVA S C R I P T (Programmation Internet) V O L . I V
J.B. Dadet DIASOLUKA Luyalu Nzoyifuanga
+243 - 851278216 - 899508675 - 991239212 - 902263541 - 813572818
La dernière révision de ce texte est disponible sur CD.
Une fonction peut être invoquée pendant même sa définition, en la faisant se terminer par une paire
de parenthèses. En fait, cela signifie que la fonction est appelée juste après sa définition et assignation éventuelle à un membre de gauche d’une affectation (expression de fonction).
<script type="text/javascript"> "use strict";
const cl=console.log;
function inlineF1(){};
// Fonction qui ne fait rien (objet vide).
//
//
function inlineF2(){}();
// SyntaxError en 5:22: expected expression, got ')'
// Le corps de la fonction [dans les accolades] doit
// contenir au moins une expression.
//
//
function inlineF3(){ cl(arguments.length) }();
// Syntactiquement OK pour les accolades, mais les
// parenthèses terminales ne doivent pas être vides.
// SyntaxError en 11:48: expected expression, got ')'
function inlineF4(){ cl(arguments.length) } ({},[]);
// Syntactiquement OK pour les parenthèses terminales
// (contiennent maintenant un objet vide comme argument'),
// à ne pas confondre avec la définition de fonction.
// Mais la fonctiuon n'exécute pas.
//
// Pour que cette fonction exécute en inline, il faut
// l'entourer de parenthèses avant les parenthèses
// terminales qui servent d'appel.
(function inlineF5(){
cl(arguments.length); //2
Petite Introduction Aux Fonctions JavaScript-II
cl(arguments);
// Arguments { 0: {}, 1: [], … }
//
// Arguments
//
0: Object { }
//
1: Array []
//
callee:
//
length: 2
cl(typeof arguments[0], typeof arguments[1]);
// object object
}
) ({},[]); // Fonction inline classique dans parenthèses.
// Son identification est superflue, et
// on ne peut pas l'appeler en didfféré.
// inlineF5()
// ReferenceError en 40:1: inlineF5 is not defined
// On peut aussi utiliser une expression de fonction,
// c'est-à-dire affecter la définition d'une fonction
// (plutôt son adresse-mémoire) , à une variable.
const inlineF6 = function(){
cl(arguments.length); // 2
cl(arguments);
// Arguments { 0: {}, 1: [], … }
//
// Arguments
//
0: Object { }
//
1: Array []
//
callee:
//
length: 2
cl(typeof arguments[0], typeof arguments[1]);
// object object
} ({},[]);
// On peut aussi appeler la fonction en cours de définition.
// Dans ce cas la définition de la fonction ne doit pas être
// dans des parenthèses. C'est comme si les parenthèses qui
// entourent la définition de la fonction rendaient la
// portée de son ID « locale » à ces parenthèses.
// On ne peut donc jamais l'appeler par son ID.
(function inlineF7(){
cl(arguments.length); // 2
cl(arguments);
// Arguments { 0: {}, 1: [], … }
//
// Arguments
//
0: Object { }
//
1: Array []
//
callee:
//
length: 2
})
//
//
//
cl(typeof arguments[0], typeof arguments[1]);
// bject object
// (inlineF7({},[]));
//
ReferenceError en 55:1:
can't access lexical declaration `inlineF8' before
initialization
mardi 31 juillet 2018
- 2 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript-II
// On ne peut non plus l'appeler en différé.
//
//=> inlineF7({a:"Appel différée O"},["Appel difféfrée A"]);
//
// ReferenceError en 61:3: inlineF7 is not defined
// La même définition que ci-dessus sans les parenthèses
// (avant celles terminales).
function inlineF8(){
cl(arguments.length); // 2
cl(arguments);
// Arguments { 0: {}, 1: [], … }
//
// Arguments
//
0: Object { }
//
1: Array []
//
callee:
//
length: 2
cl(typeof arguments[0], typeof arguments[1]);
// object object
} (inlineF8({},[]));
// Et son appel en différé :
inlineF8({b:"différé oB"},["difféfré aB"])
// 2
// Arguments { 0: {…}, 1: (1) […], … }
//
// Arguments
//
0: Object { b: "différé oB" }
//
1: Array [ "difféfré aB" ]
//
callee:
// length: 2
//
// object object
</script>
Une « fonction inline » exécute au moment de sa lecture par le browser, et disparaît près sa lecture,
libérant ainsi la RAM lui affectée et celle occupée par ses variables locales pour autant qu’elles
soient déclarées avec les mots-clés var, let ou const (obligatoire en mode "use strict"). Si on veut
conserver quelque chose de la fonction inline, il faut soit 1. Déclarer cette chose dans une variable
globale, ou 2. Demander à la fonction inline de retourner une valeur qu’on peut conserver dans une
variable, ou 3. Affecter cette valeur à une variable déclarée dans l’espace globale :
<script type="text/javascript">
let gVar;
const rVal = (function(){
gVar = "Variable de l'espace global";
ndGlobVar = "Variable globale (non spécifiée)";
window.wGlobVar = "Variable globale window explicite";
self.sGlobVar = "Variable globale self = window";
this.tGlobVar = "Variable globale this = window";
var vLocVar = "Variable locale var";
mardi 31 juillet 2018
- 3 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript-II
let lLocVar = "Variable lobale let";
const cLocVar = "Variable lobale const";
return "Valeur retournée";
})();
console.log(gVar);
console.log(ndGlobVar);
console.log(wGlobVar);
console.log(sGlobVar);
console.log(tGlobVar);
console.log(rVal);
/*
console.log(vLocVar);
// ReferenceError: vLocVar is not defined
console.log(cLocVar);
// ReferenceError: cLocVar is not defined
console.log(lLocVar);
// ReferenceError: lLocVar is not defined
*/
</script>
<script type="text/javascript"> "use strict";
const cl=console.log;
let gVar,
par1 = prompt("Donnez Paramètre 1 : ", "Our object_Param"),
par2 = prompt("Donnez Paramètre 2 : ", "Our array_Param");
par1 = {"a":par1};
par2 = [par2];
// Début de Notre fonction inline
let retInlineF = (function(){
cl(`arguments[0]["a"] = ${arguments[0]["a"]}`);
gVar = arguments[0];
return `arguments[1] = ${arguments[1]}`;
}
) (par1,par2);
// Fin de Notre fonction inline
cl('Object.values(par1) = ' , Object.values(par1));
cl('par1["a"] = ' , par1["a"]);
cl("gVar['a'] = " , gVar['a']);
mardi 31 juillet 2018
- 4 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript-II
cl();
cl("par2 = " , par2);
cl(`retInlineF = « ${retInlineF} »`);
</script>
Exécution 1 :
Exécution 2 :
Quand une fonction n’est pas inline, l’expression de fonction affecte au membre de gauche, non
pas la valeur de retour de cette fonction en cours de définition, mais son adresse-mémoire.
mardi 31 juillet 2018
- 5 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
<script type="text/javascript"> "use strict";
const cl=console.log;
let gVar,
par1 = prompt("Donnez Paramètre 1 : ", "object_Param"),
par2 = prompt("Donnez Paramètre 2 : ", "array_Param");
par1 = {"a":par1};
par2 = [par2];
// Notre fonction non inline
let retInlineF = function(){
cl("*** Dans retInlineF");
cl('arguments[0]["a"] = ' + arguments[0]["a"]);
gVar = arguments[0];
return arguments[1];
};
// Notre fonction inline
cl("*** Appel de non retInlineF()");
retInlineF(par1,par2);
// Ici, retInlineF ne prendra pas la valeur de retour
// de la fonction inline en cours de définition, mais
// l'adresse-mémoire de la fonction, il est donc
// un alias (identificateur) de fonction.
cl("\n*** De retour de retInlineF()");
cl("par1['a'] = " +par1['a']);
cl("gVar['a'] = " +gVar['a']);
cl();
cl("par2 = "+ par2);
cl("retInlineF = "+ retInlineF);
</script>
Exécution :
mardi 31 juillet 2018
- 6 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Fonctions anonymes inline :
Une fonction anonyme inline est une fonction non identifiée, sans nom, destinée à s’exécuter en
inline c’est-à-dire au moment où la page Web se charge dans le navigateur. Pour l’appeler explicitement on l’affecte (son adresse-mémoire) à une variable, on l’appelle avec cette variable avec ou
sans parenthèses.
Les parenthèses après le mot « function » dans la définition reçoivent les arguments des parenthèses à la fin de la définition de la fonction.
Les syntaxes de base d’une fonction anonyme inline sont :
(function(){})();
qui est ni plus ni moins identique à celle qui suit :
(function(){
}
)();
Ou encore celle-ci :
(function(){}());
mardi 31 juillet 2018
- 7 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
ou aussi celle-ci qui elle aussi n’est ni plus ni moins identique aux trois précédentes :
(function(){
}
());
ou celle-ci en qualité de « fonction inline à exécution immédiate »
!function(){ }();
ou cette autre fonction ordinaire inline à exécution immédiate
function(){ }(arguments,obligatoires);
En mode strict :
<script type="text/javascript"> "use strict";
function inlineF(){ } (/* sans arguments */);
// Les arguments sont obligatoires
// dans ces dernières parenthèses.
</script>
ou en mode non strict :
<script type="text/javascript">
function inlineF(){ } (/* sans arguments */);
// Les arguments sont obligatoires
// dans ces dernières parenthèses.
</script>
Dans les deux cas :
Voici la syntaxe correcte, avec arguments :
<script type="text/javascript"> "use strict";
function inlineF(){
console.log(`${arguments.length} paramètres reçus`);
} ( inlineF("Avec","liste","arguments") );
// Les arguments sont obligatoires
// dans ces dernières parenthèses.
</script>
Les parenthèses terminales dans la définition de cette fonction d’apparence ordinaire, ces parenthèses contenant ici un seul argument qui est « l’appel à la même fonction avec comme argument la
liste ("Avec"," liste"," arguments") » commandent l’exécution de cette fonction qui est pourtant en
mardi 31 juillet 2018
- 8 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
cours de définition. Cet appel immédiat (lors de la définition, comme si elle était « inline » à exécution immédiate) exécute la fonction explicitement appelée par les parenthèses au moment où le
browser lit les parenthèses c’est-à-dire au moment où il les parcourt en phase d’analyse du code
(« parsing phase »). Dans ce cas-ci précisément ces parenthèses finales DOIVENT obligatoirement
renfermer une liste (d’au moins un argument). Ces ou cet argument(s) seront utilisés comme paramètres par la fonction qui est aussi bien en cours de définition que aussi appelée dans les parenthèses et en tant que argument dans ces parenthèses.
Les parenthèses signifient toujours APPEL ou INVOCATION DE FONCTION c’est-à-dire
commandent d’« exécuter le code pointé par la valeur numérique qui lui précède et qui sera considérée comme adresse-mémoire du code à exécuter ». La définition d’une fonction retournant TOUJOURS l’adresse-mémoire de cette fonction (qui est dans notre cas-ci celle de la fonction-même qui
est en cours de définition).
On peut bien aussi appeler cette fonction de façon conventionnelle. Les paramètres qui seront utilisés par la fonction appelée viennent toujours des arguments de l’appel en cours :
<script type="text/javascript"> "use strict";
function inlineF(){
console.log(
`Les ${arguments.length} `+
`paramètres reçus sont : `+
`${Object.values(arguments)}`
);
} ( inlineF("Avec"," liste"," arguments") );
// Les arguments sont obligatoires
// dans ces dernières parenthèses.
</script>
<p onclick="inlineF(`Appel différé après le click`)">
Cliquez-moi
</p>
Cliquez-moi
Voici cette même fonction sans trop de surcharge :
<script type="text/javascript"> "use strict";
const cl = console.log;
function inlineF(){ cl(arguments[0]) } ( inlineF(1) );
</script>
mardi 31 juillet 2018
- 9 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
<p onclick="inlineF(2)"> Cliquez-moi </p>
La différence entre cette fonction inline
function(){ } ; // sans parenthèses à la fin
et les trois variantes ci-dessous :
function(){ } (arguments,obligatoires);
ou
(function(){ }) (arguments,facultatifs);
ou
(function(){ } (arguments,facultatifs));
est que la première est une fonction complètement ordinaire qui RETOURNE SON ADRESSEMÉMOIRE, alors que les trois dernières (qui sont fonctionnellement parfaitement identiques) sont
des fonctions inline, qui s’exécutent automatiquement sur le champ en RETOURNANT LE RÉSULTAT D’UN TRAITEMENT.
<script type="text/javascript"> "use strict";
let res1, res2, res3, res4 ;
//
//
//
//
sans parenthèses à la fin = DÉFINITION
la fonction retourne malgré tout [le contenu à]
l’ADRESSE-MÉMOIRE de la fonction :
« function res1() »
res1 = function(){ return arguments[0] } ;
console.log(res1); // function res1()
// avec parenthèses à la fin = APPEL
res2 = function(){ return arguments[0] } (1);
console.log(res2);
// retourne le résultat 1
res3 = (function(){ return arguments[0] }) (2);
console.log(res3);
// retourne le résultat 2
res4 = (function(){ return arguments[0] } (3));
console.log(res4);
// retourne le résultat 3
</script>
<p
<p
<p
<p
<p
onclick="console.log(res1(4))">Cliquez-moi 1</p>
onclick="console.log(res1.toString(5))">Cliquez-moi
onclick="console.log(res2.toString(6))">Cliquez-moi
onclick="console.log(res3.toString(7))">Cliquez-moi
onclick="console.log(res4.toString(8))">Cliquez-moi
mardi 31 juillet 2018
- 10 / 65 -
2</p>
3</p>
4</p>
5</p>
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Après clic de :
« Cliquez-moi 1 », « Cliquez-moi 2 », « Cliquez-moi 3 », « Cliquez-moi 4 », « Cliquez-moi 5 » :
Encore un exemple :
<script type="text/javascript">
var x=25;
"use strict";
//Mode rigoureux !
// Cette forme (exécution immédiate)
//
(function() { console.log(x) })(x);
// IDENTIQUE à cette forme si on n’a pas besoin de la valeur de retour
//
!function(x) { console.log(x) }(x);
</script>
Exécution :
25
this.html:6:7
25
this.html:10:7
Attention à votre code quand vous utilisez les fonctions à exécution immédiate.
Observez ces divers comportements des fonctions à exécution immédiate :
<script type="text/javascript"> "use strict";
// Sans les parenthèses d'exécution à la fin, n'exécute pas.
console.log( !function() {return false} ); // false
console.log( !function() {return true} ); // false
console.log( ~function() {return false} ); // -1
mardi 31 juillet 2018
- 11 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
console.log(
console.log(
console.log(
console.log(
console.log(
console.log(
console.log(
console.log(
console.log(
console.log(
console.log(
~function() {return true} ); // -1
-function() {return false} ); // Nan
-function() {return true} ); // Nan
+function() {return false} ); // Nan
+function() {return true} ); // Nan
void function() {return false} ); // undefined
void function() {return true} ); // undefined
(function() {return false}) ); // ƒ () {return
(function() {return true}) ); // ƒ () {return
function() {return false} );
// ƒ () {return
function() {return true} );
// ƒ () {return
console.log( function() {return ""}());
false}
true}
false}
true}
// ""
// Avec les parenthèses à la fin, exécute.
console.log( !function() {return false} () ); // true
console.log( !function() {return true} () ); // false
console.log( ~function() {return false} () ); // -1
console.log( ~function() {return true} () ); // -2
console.log( -function() {return false} () ); // -0
console.log( -function() {return true} () ); // -1
console.log( +function() {return false} () ); // 0
console.log( +function() {return true} () ); // 1
console.log( void function(){return false}() ); // undefined
console.log( void function() {return true}() ); // undefined
console.log( (function() {return false}) () ); // false
console.log( (function() {return true}) () );
// true
console.log( function() {return false} () );
// false
console.log( function() {return true} () );
// true
</script>
Une application de la syntaxe
function(){ } (arguments,obligatoires);
c’est par exemple quand on veut avoir les logarithmes d’une suite de nombres en des bases que
vous voulez, outre la décimale et la népérienne.
<div id="idiv"></div>
<script type="text/javascript"> "use strict";
var idiv = document.getElementById('idiv');
let base, nb, logarithme;
base = prompt("Donnez la Base : ",10);
function fBase(){
base = arguments[0];
return logabase;
function logabase(){
const res = Array.from([]);
const data = arguments[0].split(","),
l = data.length;
for(let k=0 ; k<l ; k++){
res.push(Math.log10(data[k])/Math.log10(base));
}
let stg="LOGARITHMES de ["+Object.values(data)+
"] en base "+ base+ " = "+"<br>";
for(let k=0;k<l;k++) {
mardi 31 juillet 2018
- 12 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
stg+=data[k].padStart(11,".")+" <-> "+res[k]+
`<br>${".".repeat(14)}${base}^${res[k]} = `+
`${".".repeat(5)}${Math.pow(base,res[k])}<br>`;
}
stg+="<br>";
return stg;
}
} ( logarithme = fBase(base) );
// On fixe la base à la valeur saisie au prompt.
// Saisir les nombres, séparés d'une virgule
let nbs = prompt("Donnez,les,Nombres : ");
// On calcule les logarithmes de ces nombres
// en base saisie précédemment.
idiv.innerHTML+=logarithme(nbs);
// On change de base du logarithme
logarithme = fBase(20);
// On recalcule les logarithmes des mêmes
// nombres en la nouvelle base spécifiée.
idiv.innerHTML+=logarithme(nbs);
// On veut calculer les logarithmes d'un autre
// groupe/ensemble/jeu de nompbres
nbs = "2508,17,250,9317,2560,50";
// On calcule les logarithmes des nouveaux nombres,
// en la dernière base spécifiée.
idiv.innerHTML+=logarithme(nbs);
// On change la base du logarithme à 14
logarithme = fBase(14);
// Et on veut calculer les logarithmes d'un
// nouveau groupe/ensemble/jeu de nompbres
nbs = "852,1700,2050,93170,72560,85250";
// On calcule les logarithmes des nouveaux nombres,
// en la dernière base spécifiée (14).
idiv.innerHTML+=logarithme(nbs);
</script>
Son exécution :
mardi 31 juillet 2018
- 13 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
La suite de l’exécution :
LOGARITHMES de [85749632154,374859652,85461] en base 3 =
85749632154 <-> 22.91499730423938
..............3^22.91499730423938 = .....85749632154.00024
..374859652 <-> 17.969999476778263
..............3^17.969999476778263 = .....374859652.00000054
......85461 <-> 10.336508636980033
..............3^10.336508636980033 = .....85460.99999999994
LOGARITHMES de [85749632154,374859652,85461] en base 20 =
85749632154 <-> 8.403520519998922
..............20^8.403520519998922 = .....85749632154.00003
..374859652 <-> 6.590062278538355
..............20^6.590062278538355 = .....374859652.00000006
......85461 <-> 3.7906643096107953
..............20^3.7906643096107953 = .....85460.99999999991
LOGARITHMES de [2508,17,250,9317,2560,50] en base 20 =
.......2508 <-> 2.61279720182303
..............20^2.61279720182303 = .....2507.9999999999995
.........17 <-> 0.9457498485654159
..............20^0.9457498485654159 = .....17
........250 <-> 1.843108934201204
..............20^1.843108934201204 = .....249.99999999999983
.......9317 <-> 3.050872084976957
..............20^3.050872084976957 = .....9316.999999999995
.......2560 <-> 2.619647492118314
..............20^2.619647492118314 = .....2559.9999999999995
.........50 <-> 1.3058653605207224
..............20^1.3058653605207224 = .....49.99999999999999
LOGARITHMES de [852,1700,2050,93170,72560,85250] en base 14 =
........852 <-> 2.5568169554744116
..............14^2.5568169554744116 = .....852.0000000000005
.......1700 <-> 2.81857595383452
..............14^2.81857595383452 = .....1700.0000000000018
.......2050 <-> 2.889514747011642
..............14^2.889514747011642 = .....2049.9999999999995
......93170 <-> 4.335707652896119
..............14^4.335707652896119 = .....93170.00000000009
mardi 31 juillet 2018
- 14 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
......72560 <-> 4.240972319620164
..............14^4.240972319620164 = .....72560.00000000012
......85250 <-> 4.302045002107225
..............14^4.302045002107225 = .....85250
I. Une fonction anonyme inline s'exécute automatiquement pendant le chargement de la page Web
de la même façon que les codes non contenues dans un(e) [bloc de] fonction.
<script type="text/javascript">
p="Math.PI";
// Définition fonction ordinaire.
function f(p){
console.log("Ds function f()"+p)
}
onload=fl;
// Définition fonction anonyme inline.
fonloading=(function(){ // s'exécute au chargement.
console.log("DURANT CHARGEMENT :\nDs Anonyme : " + p.substr(4,6));
f(", Depuis fonloading()");
f2(", Depuis fonloading()");
}
)(p);
p=" D U M M Y ";
// Définition fonction ordinaire.
function f2(p){
console.log("Ds function f2()"+p);
}
// Définition fonction ordinaire.
function fl(){
console.log("================\nJUSTE APRES CHARGEMENT");
f("dans fl, Depuis onload");
}
</script>
Exécution dans console.log :
DURANT CHARGEMENT :
Ds Anonyme : .PI
fonloading.html:12:4
Ds function f(), Depuis fonloading()
fonloading.html:6:2
Ds function f2(), Depuis fonloading()
fonloading.html:21:3
================
JUSTE APRES CHARGEMENT
Ds function f()dans fl, Depuis onload
mardi 31 juillet 2018
fonloading.html:26:3
fonloading.html:6:2
- 15 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
II. Expressions de fonctions (fonctions lambdas) :
Fonction comme valeur affectée à une variable à la place d'une expression = (très utile
avec les fonctions anonymes) :
Une expression de fonction est toute déclaration de fonction ne commençant pas avec
le mot-clé function.
function [nom]([param] [, param] [..., param]) {
instructions
}
Entre accolades = facultatif.
Exemple d’expression de fonction :
<script type="text/javascript"> "use strict";
let nfct1 = function(){console.log(Math.SQRT2)};
let nfct2 = _=> console.log(Math.SQRT1_2);
let nfct3 = new Function();
nfct3.fct=console.log(Math.LOG2E);
for(let k=1;k<4;k++) { eval("nfct"+k+"()"); }
</script>
// 1.4426950408889634
// 1.4142135623730951
// 0.7071067811865476
III. Déclaration de fonction génératrice (function*) :
Déclaration de fonction génératrice :
function* nom ([param[, param[, ... param]]]) {
instructions
}
mardi 31 juillet 2018
- 16 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
IV. Expression de générateur function* :
Déclaration de fonction génératrice :
function* [nom]([param] [, param] [..., param]){
instructions
}
V. Expression de fonction fléchée (=>) :
Arrow functions (“fat arrow” functions). Nouvelle syntaxe depuis ES6, mini fonctions
anonymes, plus concises (courtes : pas de mot-clé function, return est implicite selon la
fonction imbriquée utilisée, accolades =curly brackets= pas obligatoires si une seule
instruction). Une « arrow function » est liée de façon lexicale à sa valeur.
Une fonction fléchée n’a pas besoin des tokens suivants : function, return, parenthèses, accolades, et point-virgule « ; ».
<script type="text/javascript"> "use strict";
var x = _ => new Date();
console.log(x());
</script>
Exécution avec YANDEX :
Thu Jan 11 2018 21:07:37 GMT+0100 (Paris, Madrid)
Exécution avec FireFox :
Date 2018-01-11T20:09:56.001Z
__proto__: Object { … }
Une fonction fléchée ne possède pas ses propres valeurs pour this, arguments, super,
ou new.target.
Une fonction fléchée retourne par défaut la valeur de l'expression qui est à droite de la
flèche double.
mardi 31 juillet 2018
- 17 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
<script type="text/javascript"> 'use strict';
console.log((_ => Math.E)());// 2.718281828459045
</script>
Dans une fonction fléchée, le mot-clé « this » ne réfère pas cette fonction, mais le
« this » de son contexte environnemental (scope parent = portée englobante). Une fonction fléchée ne devrait donc pas être utilisée comme méthode (fonction-propriété) d’un
objet et ne peut servir comme constructeur
<script type="text/javascript"> 'use strict';
var ffl = _ => {};
// TypeError: ffl is not a constructor
//
test.html:7:14
let fflI = new ffl();
</script>
« this » référant window :
<script type="text/javascript"> 'use strict';
var nb = Math.PI;
var dObj = {
nb: Math.E,
b: _ => this, // Fct Fléchée ret window
c: function() {
return this; // Fct ord ret dObj
}
}
let retO = dObj;
var x;
console.log(x=retO.b())
// b fléchée affiche son this (window)
console.log(x.nb) // Affiche PI (window)
console.log(retO.nb) // Affiche E (local à dObj)
let retC = dObj.c(); // Appel direct de dObj.c
console.log(retC) // this = aussi dObj
console.log(retC.nb) // Affiche E
</script>
Exécution :
Window file:///K:/DADET/PROGS/test.html
test.html:18:3
3.141592653589793
test.html:21:3
2.718281828459045
test.html:22:3
Object { nb: 2.718281828459045, b: b(), c: c() }
mardi 31 juillet 2018
- 18 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
test.html:25:3
2.718281828459045
test.html:26:3
Après dépliement :
Window
dObj: {…}
b: b()
name: "b"
__proto__: function ()
c: c()
length: 0
name: "c"
prototype: Object { … }
__proto__: function ()
nb: 2.718281828459045
__proto__: Object { … }
nb: 3.141592653589793
x: Window
dObj: Object { nb: 2.718281828459045, b: b(), c: c() }
nb: 3.141592653589793
x: Window file:///K:/DADET/PROGS/test.html
[default properties]
__proto__: WindowPrototype { … }
[default properties]
__proto__: WindowPrototype { … }
test.html:18:3
3.141592653589793
test.html:21:3
2.718281828459045
test.html:22:3
{…}
b: function b()
c: function c()
nb: 2.718281828459045
__proto__: Object { … }
test.html:25:3
2.718281828459045
test.html:26:3
« this » référant la fonction englobante :
<script type="text/javascript">
"use strict";
function dObj(){
this.v = 30;
mardi 31 juillet 2018
- 19 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
this.ol
foo
foa
fob
}
=
:
:
:
{
_ => this ,
_ => this.v ,
_ => Math.PI
}
let iObj = new dObj();
console.log(iObj.ol.foo());
console.log(iObj.ol.foa());
console.log(iObj.ol.fob());
</script>
Exécution :
dObj {v: 30, ol: {…}}
ol: {foo: ƒ, foa: ƒ, fob: ƒ}
v: 30
__proto__: Object
30
3.141592653589793
La fonction fléchée n’a pas accès à un « arguments » propre, elle prend celui de son
environnement englobant.
<script>
// "use strict";
var arguments = Math.PI;
var arr = _ => arguments;
console.log(arr(100));
</script>
Exécution :
3.141592653589793
<script>
// "use strict";
function englob() {
// La fonction fléchée n'admet pas arguments
var f = (i) => arguments; // arguments de englob
return f(2); // Appel de la fct fléchée
}
console.log(englob("text",5,{},function(){}));
</script>
Exécution :
mardi 31 juillet 2018
- 20 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
(4) ["text", 5, {…}, ƒ, callee: ƒ, Symbol(Symbol.iterator): ƒ]
0: "text"
1: 5
2: {}
3: ƒ ()
callee: ƒ englob()
length: 4
Symbol(Symbol.iterator): ƒ values()
__proto__: Object
4
text
5
{}
__proto__: Object
La fonction fléchée utilise « arguments » de son environnement englobant ou même en
JS standard comme variable ordinaire (le mode strict n’autorise pas d’utiliser les motsclés [cfr arguments] comme nom de variable). On peut contourner cette restriction avec
les paramètres du reste :
<script>
"use strict";
function englob() {
// Arguments de la fonction fléchée
var ffl = (...paramRest) => paramRest;
return ffl(5,7);
}
var ret=englob("text",5,{},function(){});
console.log(ret);
console.log(ret.length);
console.log(ret[0]);
console.log(ret[1]);
console.log(ret[2]);
</script>
Exécution :
(2) [5, 7]
0: 5
1: 7
length: 2
__proto__: Array(0)
2
mardi 31 juillet 2018
- 21 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
5
7
undefined
Si la fonction fléchée ne renvoie pas automatiquement la valeur escomptée, forcez avec
un return explicite.
Si la fonction doit seulement créer et retourner un littéral d'objet, l’littéral d'objet à
retourner doit être entouré de parenthèses pour ne pas le confondre avec un corps de
fonction, ou alternativement retournez l’objet avec un return explicite :
Exemple 1 : On ne transmet rien en argument et l’littéral d'objet est créé par la fonction fléchée :
<script type="text/javascript"> "use strict";
// object literal (notez les parenthèses)
// return implicite.
var f = () => ({ matr:1234 , nom:"texte" });
console.log(f);
console.log(f());
console.log(f().matr);
console.log(f().nom);
</script>
Exécution :
function f()
test.html:7:3
Object { matr: 1234, nom: "texte" }
test.html:8:3
1234
test.html:9:3
texte
test.html:10:3
Exemple 2 : On transmet des primitives en arguments et l’littéral d'objet est créé et
retourné par la fonction fléchée :
<script type="text/javascript"> "use strict";
// object literal (notez les parenthèses)
// return implicite.
var f = (x,y) => ({ matr:x , nom:y });
// 1er lot de Candidat :
console.log(f(123 , "Diasolukov"));
console.log(f(145 , "Kenakov").matr);
console.log(f(167 , "Beliokovicz").nom);
// 2e lot de Candidat :
console.log(f(234 , "Benjiokovicz"));
console.log(f(256 , "Lorenkov").matr);
mardi 31 juillet 2018
- 22 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
console.log(f(278 , "Bastokov").nom);
</script>
Exécution :
Object { matr: 123, nom: "Diasolukov" }
test.html:8:2
145
test.html:9:2
Beliokovicz
test.html:10:2
Object { matr: 234, nom: "Benjiokovicz" }
test.html:13:2
256
test.html:14:2
Bastokov
test.html:15:2
Exemple 3 : Création et renvoi par la fonction fléchée d’un littéral d'objet non entouré
de parenthèses ni d’accolades avec retour explicite :
<script type="text/javascript">
"use strict";
// Vu comme bloc de fonction sans «return»
// Ici retournera « undefined » par défaut
// Création littéral d'objet
const objF = obj => { key: obj.nom; };
console.log(objF({nom:"xyz"}));
</script>
Exécution :
undefined
Écrivez plutôt :
<script type="text/javascript">
"use strict";
let objF = obj => { // Bloc de fonction
return {alias: obj.nom}; //Retour Littéral d'objet
};
console.log(objF({nom:"xyz"}));
console.log(objF({nom:"xyz"}).alias);
</script>
Ou mieux
<script type="text/javascript">
"use strict";
// Littéral d'objet entre parenthèses
mardi 31 juillet 2018
- 23 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
let objF = obj => ({
alias: obj.nom
}); // Retour implicite de l’littéral d'objet
console.log(objF({nom:"xyz"}));
console.log(objF({nom:"xyz"}).alias);
</script>
Exécution pour les deux :
Object { alias: "xyz" }
test.html:8:3
xyz
test.html:9:3
Une fonction fléchée n’est pas (ne peut être) un constructeur et ne peut donc pas avoir
de descendants.
<script type="text/javascript">
"use strict";
let foo = _ => Math.E
console.log(foo); // Pointeur sur foo();
console.log(foo()); // Retour de foo();
var iobj = new foo(); // Instanciation de foo()
</script>
Exécution :
function foo()
test.html:6:3
2.718281828459045
test.html:7:3
TypeError: foo is not a constructor
test.html:8:14
Syntaxe des fonctions fléchées :
N.B.: Pas de saut de ligne entre la liste des paramètres et la flèche d'une fonction fléchée (AVANT.
la double flèche).
Fonction fléchée à un seul paramètre :
p => instructions;
Exemple :
mardi 31 juillet 2018
- 24 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
<script type="text/javascript"> "use strict";
var f = txt => txt.split(" "); // return explicie
console.log(f("Diasoluka Luyalu Nzoyifuanga"));
</script>
Exécution :
Array [ "Diasoluka", "Luyalu", "Nzoyifuanga" ]
[…]
0: "Diasoluka"
1: "Luyalu"
2: "Nzoyifuanga"
length: 3
__proto__: Array []
Fonctions fléchées à deux paramètres ou plus :
La liste de paramètres formels est entourée de parenthèses :
(p1, p2, ... pn) => expressions;
Exemple :
<script type="text/javascript">
"use strict";
// Avec Fonction fléchée
var ajouter = (id, name) =>
({ matr:"Matr="+id, nom:"Name="+name });
const ret=ajouter (5, "Kaleidoscope");
console.log(ret);
// Avec Fonction classique
var ajout = function (id, name) {
return {
matr: "Matr="+id,
nom: "Name="+name
};
};
const ret2=ajout(10, "Vladivostock");
console.log(ret2);
</script>
Exécution :
mardi 31 juillet 2018
- 25 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Object { matr: "Matr=5", nom: "Name=Kaleidoscope" }
test.html:8:3
Object { matr: "Matr=10", nom: "Name=Vladivostock" }
test.html:18:3
Si plusieurs arguments ou aucun du tout, ou avec des paramètres du reste, ou avec des
valeurs par défaut, ou un paramètre qui utilise une décomposition, entourez-les de parenthèses.
Ci-dessous, la fonction fléchée « fct » a deux paramètres, séparés par une virgule et entourés d’une paire de parenthèses :
« [a,b] = [v,w] »
et
« {x:c , y:d} = {x:a+b , y:a*b} »
, sous forme de « décomposition pour la liste des paramètres » :
la variable « a » prend la valeur de v=3, et
la variable « b » prend la valeur de w=5, et
la propriété « c » prend la valeur « a+b » = 8,
la propriété « d » prend la valeur « a*b » = 15,
pour l’expression « a+b * c+d » retournée implicitement et qui vaut 58.
Attention : « a+b * c+d » === « a + (b*c) + d ».
Fonction fléchée Sans paramètres :
La place que devait occuper les paramètres formels est symbolisée par des parenthèses
vides « () » ou un trait de soulignement « _ » :
() = > expressions;
Exemple 1 :
mardi 31 juillet 2018
- 26 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
<script type="text/javascript"> "use strict";
// return implicite « undefined »
// consolog.log affiche "Bougez !"
// et retourne « undefined »
var f = () => console.log("Bougez !");
f(); // Appel de la fonction fléchée
// Valeur « undefined » retournée par
// console.log dans la fonction f()
console.log(f());
</script>
Exécution :
Bougez !
test.html:7:17
undefined
test.html:14:3
Exemple 2 :
<script type="text/javascript">
f = () => console.log("LN de 10 = "+Math.log(10));
console.log(f());
</script>
Exécution :
LN de 10 = 2.302585092994046
undefined
Syntaxe minimale complète :
()=>{}
//fonction fléchée vide, renvoie undefined
ou
_=>{}
//fonction fléchée vide, renvoie undefined
Sa syntaxe détaillée :
mardi 31 juillet 2018
- 27 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
([param] [, param]) => {
expressions
}
Sa syntaxe minimaliste :
param => expression
param : nom d'un argument, paire de parenthèses () si pas d'arguments ou si au moins deux arguments. Si un seul argument, parenthèses pas obligatoires :
Exemple de syntaxe minimaliste :
<script type="text/javascript">
// Fonction classique
function a() { return "typeof a = " + typeof a}
console.log( a );
console.log( a() );
// Fonction fléchée
var b = ( _ => "typeof b = " + typeof b);
console.log( b );
console.log( b() );
</script>
Exécution avec FireFox :
function a()
test.html:4:4
a()
arguments: null
caller: null
length: 0
name: "a"
prototype: Object { … }
__proto__: function ()
typeof a = function
test.html:5:4
function b()
test.html:9:4
name: "b"
__proto__: function ()
mardi 31 juillet 2018
- 28 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
typeof b = function
test.html:10:4
Exécution avec YANDEX :
ƒ a() { return "typeof a = " + typeof a}
test.html:4
typeof a = function
test.html:5
_ => "typeof b = " + typeof b
test.html:9
typeof b = function
test.html:10
instructions ou expression
Si plusieurs instructions, les encadrer par des accolades. Si expression unique, accolades pas
obligatoires. expression est aussi la valeur de retour implicite de la fonction.
Exemple 1 :
<script type="text/javascript"> "use strict";
var x = () => console.log("Haut");
var y = _ => console.log("Bas");
x(); y();
</script>
Exécution :
Haut
Bas
Exemple 2 :
<script type="text/javascript"> "use strict";
var x = (p) => console.log(p);
var y = (q) => console.log(q);
x(10); y( ()=>25 );
</script>
Exécution :
10
mardi 31 juillet 2018
- 29 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
test.html:3:18
function ()
()
length: 0
name: ""
__proto__: ()
apply: function apply()
arguments: null
bind: function bind()
call: function call()
caller: null
constructor: function Function()
isGenerator: function isGenerator()
length: 0
name: ""
toSource: function toSource()
toString: function toString()
Symbol(Symbol.hasInstance): undefined
__proto__: Object { … }
Exemple 3 :
<script type="text/javascript"> "use strict";
var v = x => { return "LN de "+x+" = "+Math.log(x); }
console.log(v(Math.exp(1))); // LN de E
console.log(v(Math.E)); // LN de E
</script>
Exécution :
LN de 2.7182818284590455 = 1
LN de 2.718281828459045 = 1
Exemple 4 :
<script type="text/javascript"> "use strict";
var arf = (x,y,z) => {
return "1 GigaByte = "+
mardi 31 juillet 2018
- 30 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Math.pow(Math.pow(x,y),z)+" Bytes"
};
console.log(arf(2,10,3));
</script>
Exécution :
1 GigaByte = 1073741824 Bytes
Fonctions fléchées avec les Arrays :
La fonction fléchée ne contient que la structure des enregistrements :
<script type="text/javascript">
"use strict";
var fn = (id, name) => ({id:id, name:name});
console.log( fn (4, "Kyle") );
</script>
Exécution :
Object { id: 4, name: "Kyle" }
{id: 4, name: "Kyle"}
id: 4
name: "Kyle"
__proto__: Object
constructor: ƒ Object()
hasOwnProperty: ƒ hasOwnProperty()
isPrototypeOf: ƒ isPrototypeOf()
propertyIsEnumerable: ƒ propertyIsEnumerable()
toLocaleString: ƒ toLocaleString()
toString: ƒ toString()
valueOf: ƒ valueOf()
__defineGetter__: ƒ
__defineGetter__()
__defineSetter__: ƒ __defineSetter__()
__lookupGetter__: ƒ __lookupGetter__()
__lookupSetter__: ƒ __lookupSetter__()
get __proto__: ƒ __proto__()
set __proto__: ƒ __proto__()
mardi 31 juillet 2018
- 31 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
ou, la fonction fléchée contient les données des enregistrements :
<script type="text/javascript">
pers = [
{ id:'Pet', Mat:150 },
{ id:'Jean', Mat:2500 },
{ id:'July', Mat:1000 }
];
// Pour chaque membre de pers (map)
// cette Array pers est mise en argument
// et retourne implicitementson mat.
console.log(pers.map(
pers => pers.id+" = "+pers.Mat));
</script>
Exécution :
Array [ "Pet = 150", "Jean = 2500", "July = 1000" ]
test.html:12:3
1er
A
B
C
D
E
(3) ["Pet = 150", "Jean = 2500", "July = 1000"]
0:"Pet = 150"
1:"Jean = 2500"
2:"July = 1000"
length:3
__proto__:Array(0)
Une variante plus complexe de ce qui précède :
<script type="text/javascript">
"use strict";
var pers = [
{ id:'Pet', Matr:150 },
{ id:'Jean', Matr:250 },
{ id:'July', Matr:100 }
];
// Pour chaque membre de pers (map)
// cette Array pers est mise en argument
// et retourne implicitementson Matr.
console.log(pers.map(
x => x.id+" = "+x.Matr));
console.log(">========<");
var map = new Map(Object.entries(pers));
console.log(map);
console.log("X========X");
mardi 31 juillet 2018
- 32 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
console.log(pers.map(
x => new Map(Object.entries(x))));
console.log("<========>");
var db = pers.map(x => x);
console.log(db);
console.log(db.map(
x => new Map(Object.entries(x))));
console.log("====X====");
db = pers.map(x => [x]);
console.log(db);
console.log(db.map(
x => new Map(Object.entries(x))));
</script>
Exécution dans la console de YANDEX :
A
(3) ["Pet = 150", "Jean = 250", "July = 100"]
test.html:14
1er
A
B
C
D
E
(3) ["Pet = 150", "Jean = 250", "July = 100"]
0:"Pet = 150"
1:"Jean = 250"
2:"July = 100"
length:3
__proto__:Array(0)
>========<
test.html:17
Map(3) {"0" => {…}, "1" => {…}, "2" => {…}}
test.html:20
1er
Map(3) {"0" => {…}, "1" => {…}, "2" => {…}}
A
size:(...)
B
__proto__:Map
C
[[Entries]]:Array(3)
I
0:{"0" => Object}
II
1:{"1" => Object}
III
2:{"2" => Object}
IV
length:3
X========X
test.html:22
(3) [Map(2), Map(2), Map(2)]
test.html:24
1er
A
B
C
D
E
(3) [Map(2), Map(2), Map(2)]
0:Map(2) {"id" => "Pet", "Matr" => 150}
1:Map(2) {"id" => "Jean", "Matr" => 250}
2:Map(2) {"id" => "July", "Matr" => 100}
length:3
__proto__:Array(0)
<========>
test.html:27
(3) [{…}, {…}, {…}]
test.html:30
1er
(3) [{…}, {…}, {…}]
A
0:{id: "Pet", Matr: 150}
B
1:{id: "Jean", Matr: 250}
mardi 31 juillet 2018
- 33 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
C
D
E
2:{id: "July", Matr: 100}
length:3
__proto__:Array(0)
(3) [Map(2), Map(2), Map(2)]
test.html:31
1er
0:Map(2) {"id" => "Pet", "Matr" => 150}
2e 1:Map(2) {"id" => "Jean", "Matr" => 2500}
3e 2:Map(2) {"id" => "July", "Matr" => 1000}
4e length:3
5e __proto__:Array(0)
====X====
test.html:34
(3) [Array(1), Array(1), Array(1)]
test.html:37
1er
A
B
C
D
E
(3) [Array(1), Array(1), Array(1)]
0:[{…}]
1:[{…}]
2:[{…}]
length:3
__proto__:Array(0)
(3) [Array(1), Array(1), Array(1)]
test.html:37
1er
Array(1)
A
0:{id: "Pet", Matr: 150}
B
length:1
C
__proto__:Array(0)
1er
1:Array(1)
A
0:{id: "Jean", Matr: 250}
B
length:1
C
__proto__:Array(0)
1er
2:Array(1)
A
0:{id: "July", Matr: 100}
B
length:1
C
__proto__:Array(0)
1er
length:3
2e __proto__:Array(0)
(3) [Map(1), Map(1), Map(1)]
1er
A
B
C
D
E
1er
A
B
C
I
a
b
I
1er
A
B
C
I
a
test.html:38
(3) [Map(1), Map(1), Map(1)]
0:Map(1) {"0" => {…}}
1:Map(1) {"0" => {…}}
2:Map(1) {"0" => {…}}
length:3
__proto__:Array(0)
0:Map(1)
size:(...)
__proto__:Map
[[Entries]]:Array(1)
0:{"0" => Object}
key:"0"
value:{id: "Pet", Matr: 150}
length:1
1:Map(1)
size:(...)
__proto__:Map
[[Entries]]:Array(1)
0:{"0" => Object}
key:"0"
mardi 31 juillet 2018
- 34 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
b
value:{id: "Jean", Matr: 2500}
I
length:1
1er
2:Map(1)
A
size:(...)
B
__proto__:Map
C
[[Entries]]:Array(1)
I
0:{"0" => Object}
a
key:"0"
b
value:{id: "July", Matr: 1000}
I
length:1
1er
length:3
2e __proto__:Array(0)
En plus simple :
<script type="text/javascript">
"use strict";
var obj = { Nom: "Pierre", Matr: 123 ,
Titre: "Bel Ami" , Prix: 100};
var map = new Map(Object.entries(obj));
console.log(map);
</script>
Exécution avec YANDEX :
1er Map(4) {"Nom" => "Pierre", "Matr" => 123, "Titre" => "Bel
Ami", "Prix"=> 100}
A
size:(...)
B
__proto__:Map
C
[[Entries]]:Array(4)
I
0:{"Nom" => "Pierre"}
II
1:{"Matr" => 123}
III
2:{"Titre" => "Bel Ami"}
IV
3:{"Prix" => 100}
V
length:4
Exécution avec FIREFOX :
Map { Nom → "Pierre", Matr → 123, Titre → "Bel Ami", Prix → 100 }
test.html:6:3
Map
size: 4
<entries>
0: Nom → "Pierre"
1: Matr → 123
2: Titre → "Bel Ami"
mardi 31 juillet 2018
- 35 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
3: Prix → 100
__proto__: Object { … }
Visualisation du code de la fonction fléchée dans la console :
Array [ "Pierre = 150", "Jean-Baptste = 2500", "Juliana = 1000" ]
[…]
0: "Pierre = 150"
1: "Jean-Baptste = 2500"
2: "Juliana = 1000"
length: 3
__proto__: []
concat: function concat()
constructor: function Array()
copyWithin: function copyWithin()
entries: function entries()
every: function every()
fill: function fill()
filter: function filter()
find: function find()
findIndex: function findIndex()
forEach: function forEach()
includes: function includes()
indexOf: function indexOf()
join: function join()
keys: function keys()
lastIndexOf: function lastIndexOf()
length: 0
map: function map()
pop: function pop()
push: function push()
reduce: function reduce()
reduceRight: function reduceRight()
reverse: function reverse()
shift: function shift()
slice: function slice()
some: function some()
mardi 31 juillet 2018
- 36 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
sort: function sort()
splice: function splice()
toLocaleString: function toLocaleString()
toSource: function toSource()
toString: function toString()
unshift: function unshift()
Symbol(Symbol.iterator): undefined
Symbol(Symbol.unscopables): undefined
__proto__: {…}
__defineGetter__: function __defineGetter__()
__defineSetter__: function __defineSetter__()
__lookupGetter__: function __lookupGetter__()
__lookupSetter__: function __lookupSetter__()
constructor: function Object()
hasOwnProperty: function hasOwnProperty()
isPrototypeOf: function isPrototypeOf()
propertyIsEnumerable: function propertyIsEnumerable()
toLocaleString: function toLocaleString()
toSource: function toSource()
toString: function toString()
unwatch: function unwatch()
valueOf: function valueOf()
watch: function watch()
VI. Avec le constructeur Fonction (new Function) :
Pas très commode.
new Function (arg1, arg2, ... argN, corpsDeFct)
VI Fonction anonyme inline :
Exécute au chargement du fichier et ordinairement une seule fois. Appelée « expression
de fonction immédiatement invoquée » (Immediately Invokable Function Expression =
IIFE). Les IIFE sont appelées dès la fin de leur déclaration. Les parenthèses terminales
commandent d’ailleurs l’exécution immédiate de la fonction
(function()
/*
{
instruction
mardi 31 juillet 2018
*/
- 37 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
})();
Si une fonction ordinaire passe son adresse à la variable de gauche lors de sa définition,
une IIFE n’affecte pas son adresse à la variable. Il ne sert donc à rien d’écrire :
var f = (function(){ console.log (this) })();
// TypeError: f is not a function
//
f();
Exécution :
this n’est pas reconnu.
Undefined
test.html:4:22
Tout objet soit-il fonction (son adresse) peut être affecté à une variable.
Les fonctions appelées (avec parenthèses) retournent toujours la valeur de l’expression qui suit la
directive return, par défaut (quand cette directive ne figure pas dans la fonction ou quand elle ne
spécifie pas une valeur de retour) elles retournent undefined.
Pendant la définition d’une fonction non inline (IIFE) ou quand une fonction est invoquée sans parenthèses en dehors de définition, elle retourne son adresse-mémoire (pointeur).
Exemple 1 :
<script type="text/javascript">
"use strict";
// Fonction inline, exécute
var pi = (() => Math.PI)();
// Affiohe valeur retournée ci-haut
console.log(pi);
// Fonction à exécution différée
var nep = () => Math.E;
// Exécution de la fonction
console.log( nep() );
</script>
Exécution :
3.141592653589793
test.html:12 2.718281828459045
mardi 31 juillet 2018
- 38 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Exemple 2 :
<script type="text/javascript">
"use strict";
// Il exécute directement et
// retourne ici même une valeur.
// On ne peut l'appeler de nulle part ailleurs
var foa = (function(){
return("Ret in foa")
})();
// Il n'exécute pas directement et
// retourne ici l'adrersse de son adresse
var FOB = function(){
return("Ret in FOB")
};
console.log(foa); // Contenu retourné à foa
console.log(FOB); // Contenu à l'adresse de FOB
console.log(FOB()); // Exécute Contenu pointé
// à l'adresse de FOB
</script>
Exécution :
Ret in foa
ƒ (){
return("Ret in FOB")
}
Ret in FOB
Exemple 3 :
<script type="text/javascript">
"use strict";
var dObj = function(){
this.v=45;
console.log (this);
return this;
};
// Instanciation de dObj()
var foo = new dObj();
// Pointeur sur dObj() cô fonction
var fof = dObj;
// Instanciation de foo()
// TypeError: foo is not a constructor
mardi 31 juillet 2018
- 39 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
// Une instance ne peut être constructeur
//
var fop = new foo();
console.log(dObj); // Pointeur sur constructeur
console.log(foo); // Pointeur sur l'instance
console.log(foo.v); // Accès à propriété d'objet
console.log(fof); // Pointeur sur fonction dObj
console.log(fof.v); // undefined
</script>
Exécution :
Rendez-vous bien aux numéros des lignes.
dObj {v: 45}
test.html:6:5
function dObj()
test.html:21:1
ƒ (){
this.v=45;
console.log (this);
return this;
}
dObj {v: 45}
test.html:22:1
45
test.html:23:1
function dObj()
test.html:24:1
ƒ (){
this.v=45;
console.log (this);
return this;
}
undefined
test.html:25:1
Affectation d'une fonction :
1. Par fonction anonyme : Par affectation à une variable, de l’adresse de la fonction anonyme inline pendant sa définition.
a. var v=(function(){})();
mardi 31 juillet 2018
- 40 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Définition et affectation d’une fonction anonyme non inline :
b. var v=function(){};
2. Par identification de fonction : idem que 1b.
c. var v=function v(){};
Affectation de l’adresse (et appel) de la fonction ci-dessus (dans c).
N.B.: Pas de parenthèses dans le nom de la fonction affectée :
d. af=v ; af();
3. Adresse de la fonction retournée par la fonction englobante.
<script type="text/javascript">
function f1(){
// f3 = adresse de la fonction f2() en cours de définition
var f3=function f2(){
console.log("Dans function f2()")
}
return f3; // retourne un pointeur sur f2()
}
// v prend l'adresse de la fonction f2() retournée par f1().
v=f1()
// appel de la fonction f2() notez les parenthèses
v()
</script>
Exécution dans console.log :
Dans function f2() fcts.html:4
En fait, l'identifieur « f2 » ci-dessus ne sert absolument à rien.
<script type="text/javascript">
f=function f2(){
console.log(new Date());
}
f();
f2();
</script>
mardi 31 juillet 2018
- 41 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Exécution :
Date 2017-12-25T00:04:18.791Z
id_rien.html:3:3
ReferenceError: f2 is not defined
id_rien.html:7:2
Une autre fonction expression (type b. ci-dessus) :
<script type="text/javascript">
var age = function(dn) {
j = new Date();
return (j-dn)/1000/3600/24/365.2475
};
x = age(new Date("11 August 1953"));
console.log(x+" ans.");
</script>
Exécution dans console.log :
64.36071000983478 ans. fvar_age.html:8
Le membre de gauche de l’affectation d’une fonction peut être une propriété
d’objet, p. ex.
« onclick » pour créer un événement :
<body>
<div><p>Cliquez ici</p></div>
<p>Léger <strong>Gras</strong> Léger</p>
</body>
<script>
//Accès au PREMIER paragraphe
var pc = document.querySelector('p');
//Création de gestionnaire d'évènement "onclick"
pc.onclick = function(){
this.innerHTML = 'Le click a été savoureux !';
this.style.color = "red";
this.style.borderStyle = "solid";
this.style.borderColor = "blue";
this.style.padding = "1em";
this.style.backgroundColor = "yellow";
this.style.width = "12em";
this.style.fontWeight = '900';
};
</script>
</html>
Exécution :
mardi 31 juillet 2018
- 42 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Avant le click :
Cliquez ici
Léger Gras Léger
Après le click :
Le click a été savoureux !
Léger Gras Léger
Bien entendu, on peut écrire ceci :
pc.onclick = function(){
corps de la fonction anonyme
};
par exemple comme ceci :
pc.onclick = fadr // Notez absence de parenthèses.
fadr=function(){
corps de la fonction anonyme
};
ou comme ceci :
pc.onclick = fadr // Notez absence de parenthèses.
function fadr (){
corps de la fonction anonyme
};
Et au lieu de :
pc.onclick = fadr // Notez absence de parenthèses.
on peut écrire :
pc. addEventListener('click',fadr,false);
mardi 31 juillet 2018
- 43 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Au lieu d’adresse de fonction comme paramètre, on peut directement utiliser une fonction anonyme
s’exécutant sur place :
pc.addEventListener('click',function(){
this.innerHTML = 'Le click a été savoureux !';
...
this.style.fontWeight = '900';
});
Passation de paramètres avec les différentes définitions de fonctions :
Toute fonction peut passer/recevoir des paramètres d’un des 7 types de donnéeJS valides : n u m b e r (y compris le NaN), string, boolean (true ou false), object, function, null
(vide = « absence de / aucune » valeur) et undefined. Mais JS affiche le « typeof null » comme
étant un object (avec petit « o ») au lieu de null (erreur de JS). De plus « undefined » = aucune
valeur affectée (néant), tandis que « null » = valeur affectée mais ne représentant rien.
Attention donc à NaN, null et undefined.
Exemple :
var vnull = null; // Affectation d’une valeur ne représentant rien.
var vundefined; // Aucune valeur affectée même pas le null.
Undefinde :
Attention aux guillemets :
var z;
typeof z -> "undefined"
z==undefined -> true
z=="undefined" -> false
(typeof z)==undefined -> false
(typeof z)=="undefined" -> true
undefined -> undefined
undefined=="undefined" -> false
nonexist ->
Uncaught
mous>:1:1
ReferenceError:
mardi 31 juillet 2018
nonexist
- 44 / 65 -
is
not
defined
at
<anony-
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
null :
var z;
typeof z -> "object"
z==undefined -> true
z=="undefined" -> false
(typeof z)==undefined -> false
(typeof z)=="undefined" -> false
Contrairement aux langages C/C++, JS ne possède pas les types de données enum, structure...., et
même les objets en JS ne sont pas vraiment comme les classes dans C/C++.
1. Définition classique de Fonction :
Avec le mot-clé function suivi du nom identifiant et de la liste de paramètres formels entre parenthèses max 255d (0xFF) paramètres/arguments, puis du bloc d’instruction de la fonction (corps
de la fonction) entouré d’accolades (curly braces).
function nom([param[, param[, ... param]]]) {
instructions;
}
Exemple :
<script type="text/javascript">
// Déclaration/définition de fonction
function fclassic(p1, p2, p3, p4, p5, p6, p7){
console.log(typeof p1,typeof p2,
typeof p3,typeof p4,typeof p5,
typeof p6,typeof p7,typeof p8)
}
// Appel de la fonction
fclassic(0/0,{PI:Math.PI},"Math.PI",
(function(){return 5==7})(),
window,[],String)
</script>
Le paramètre p7 (type = undefined) n’a reçu aucun argument.
Exécution :
mardi 31 juillet 2018
- 45 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
N.B. :
Ne confondez pas « types de données » (minuscules) et « objets standard » (Capitalisés) : Pour les
instancier il faut utiliser l’opérateur new et appeler leur constructeur comme une fonction, p. ex
new Date().
2. Fonction anonyme_1 :
<script type="text/javascript">
// Déclaration/définition de fonction
fanonyme1=function(p1){
return p1.substr(4,6);
};
// Appel à la fonction
console.log(fanonyme1("Math.PI"));
</script>
Exécution :
.PI
fano.html:9:2
Attention ici :
a) fanonyme1=function(p1){...} :fanonyme prend l’adresse pointée par la fonction, soit-elle
anonyme ou ordinaire.
b) v=fanonyme1("Math.PI") :v prend la valeur retournée par la fonction anonyme dont fanonyme1 avait pris l’adresse.
3. Fonction anonyme_2 :
Fonction anonyme inline affectée à fano, appel sans les parenthèses :
<script type="text/javascript">
// Déclaration/définition de fonction
fano=(function(){
console.log(4 + 6 + " | 4 + 6 = "+ 4 + 6);
} )();
// Appel à la fonction
mardi 31 juillet 2018
- 46 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
fano();
</script>
Exécution :
10 | 4 + 6 = 46 typeof.html:4:3
4. Fonction anonyme_3 :
Fonction anonyme inline affectée à v, appel avec les parenthèses :
<script type="text/javascript">
var cpt=cptr=0;
v = (function(p1,p2){
var x=0;
var f3=function(){
console.log("Ds f2(): p1= ++cptr="+p1+
" , ++cpt="+ ++cpt+" , x="+x++ +
" , p2="+p2.toLocaleString())
};
return f3;
})(++cptr,d());
for(k=0;k<2;k++) v("ignored1","ignored2");
function d(){return new Date()}
</script>
Exécution :
Ds f2(): p1= ++cptr=1 , ++cpt=1 , x=0 , p2=21/12/2017 à 12:41:49
Ds f2(): p1= ++cptr=1 , ++cpt=2 , x=1 , p2=21/12/2017 à 12:41:49
5. En général :
<script>
function go(){
document.write(arguments.length+" Arguments :<br>");
for(let k=0,l=arguments.length ; k<l ; k++) {
document.write(arguments[k] + " | ");
}
document.write("<br>");
for(let k in arguments) document.write(arguments[k] + " | ")
mardi 31 juillet 2018
- 47 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
}
go("sérénité",new Date().toLocaleString(),
Math.LN2.toFixed(2),2017)
</script>
Exécution :
4 Arguments :
sérénité | 21/12/2017 à 01:02:59 | 0.69 | 2017 |
sérénité | 21/12/2017 à 01:02:59 | 0.69 | 2017 |
6. Polymorphisme de fonction dans JavaScript :
Il n’existe pas de polymorphisme (overloading) de fonction dansJS vs C++ (voir p. 2/26 du Tome
II de la série «À la découverte du langage C++» : Tout sur les Objets dans le Langage C, 1993, du
même auteur). On gère cet état soi-même en testant le type de l’argument passé :
<script type="text/javascript">
polymorphisme=function(p1,p2){
if(typeof arguments[1]=="undefined"){
console.log(p1+".p2==undefined")
}
if(typeof arguments[1]=="string"){
console.log(p1+". p2==string")
}
if(typeof arguments[1]=="number"){
console.log(p1+". p2==number")
}
if(typeof arguments[1]=="null"){
console.log(p1+". p2==null")
}
if(typeof arguments[1]=="function"){
console.log(p1+". p2==function")
}
if(typeof arguments[1]=="boolean"){
console.log(p1+". p2==boolean")
}
if(typeof arguments[1]=="object"){
console.log(p1+". p2==object")
}
}
var a=[], b='diasoluka', c="1953";
polymorphisme(1,"");
polymorphisme("1b","p2");
polymorphisme("1c",b);
polymorphisme("1d",c);
polymorphisme("1e",typeof Math);
polymorphisme(2,5);
polymorphisme("2b",eval("11"+"8"));
polymorphisme(3,{});
polymorphisme("3b",new String());
polymorphisme("3c",Math);
mardi 31 juillet 2018
- 48 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
polymorphisme("3d",null);
polymorphisme(4);
polymorphisme("4b",undefined);
polymorphisme(5, 4!=4);
polymorphisme("5b",(function(){return true})());
polymorphisme(6,Boolean);
polymorphisme("6d",Function);
polymorphisme("6c",function(){});
</script>
Exécution :
1. p2==string ,1b. p2==string ,1c. p2==string ,1d. p2==string ,1e. p2==string
2. p2==number ,2b. p2==number
3. p2==object , 3b. p2==object , 3c. p2==object , 3d. p2==object
4.p2==undefined , 4b.p2==undefined
5. p2==boolean , 5b. p2==boolean
6. p2==function , 6d. p2==function , 6c. p2==function
7. p2==string
7. Passation d’arguments «par valeur» et «par référence» en JS :
Les modifications apportées à un arguments passé par valeur (by value) dans la fonction appelée ne
diffusent pas en dehors de la fonction.
Les modifications apportées aux membres (attributs) d’un objet passé « par valeur » à une fonction
appelée se reflètent en dehors de la fonction appelée. Le type object est donc un moyen de passer un
argument par référence.
<script>
f=function(obj,j,m,a) {
obj.x *= 3;
// devient 33 dans l’objet
obj.y += 10; // devient 18 dans l’objet
obj.z -= 10; // devient 1943 dans l’objet
j *= 3; // modifications locales
m += 10;
a -= 10;
}
<script>
f=function(obj,j,m,a) {
obj.x *= 3; // devient 33 dans l’objet
obj.y += 10; // devient 18 dans l’objet
obj.z -= 10; // devient 1943 dans l’objet
j *= 3; // modifications locales
m += 10;
mardi 31 juillet 2018
- 49 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
a -= 10;
};
var odummy = {
x: 0,
y: 1,
z: 2
};
// Paramètres initiales.
var j=j1=11, m=m1=8, a=a1=1953;
console.log("Valeurs initiales : "+
"j1="+j1+" m1="+m1+" a1="+a1);
// On les place dans un objet.
odummy.x=j; odummy.y=m; odummy.z=a;
// Appel de la fonction f()
// Passation de l'objet cô argument (par référence)
// Passation de j,m,a par valeur
f(odummy,j1,m1,a1);
// On récupères les valeurs modifiées
j=odummy.x; m=odummy.y; a=odummy.z;
console.log("Valeurs retournées : "+
"j="+j+" m="+m+" a="+a);
console.log("Valeurs retournées : "+
"j1="+j1+" m1="+m1+" a1="+a1);
</script>
Exécution :
Valeurs initiales : j1=11 m1=8 a1=1953
Valeurs retournées : j=33 m=18 a=1943
Valeurs retournées : j1=11 m1=8 a1=1953
Fonctions imbriquées :
Le code ci-dessous exécute l’addition de la fonction la plus interne.
<script type="text/javascript">
function d_nais(jr){
return function (ms){
return function (an){
return an+ms+jr;
}
}
}
mardi 31 juillet 2018
- 50 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
console.log(d_nais(30)(5)(10))
</script>
Exécution :
45
Que s’est-il passé ? Voyons-le « images » étape par étape.
Lisez bien les commentaires.
<script type="text/javascript">
function d_nais(jr){
return function mois(ms){
return function annee(an){
return jr+"/"+ms+"/"+an;
}
}
}
console.log(d_nais(30)(12)(2017))
</script>
Exécution :
30/12/2017
Un autre exemple :
<script type="text/javascript">
function d_nais(an){
console.log("=> Dans d_nais()");
return function mois(ms,hr){
console.log("=> Dans mois()");
return function jour(jr,mn,sc){
console.log("=> Dans jour()");
return (
"=> "+new Date(an,ms-1,jr,hr,mn,sc)
).toString();
}
}
}
console.log(d_nais); // Affiche d_nais()
console.log(d_nais()); // Exécute d_nais et affiche mois()
// Exécute jusqu'à mois et affiche jour()
console.log(d_nais()());
// Exécute jusqu'à jour
mardi 31 juillet 2018
- 51 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
console.log(d_nais(1953)(11,15)(7,30,22));
</script>
Exécution :
function d_nais()
=> Dans d_nais()
function mois()
=> Dans d_nais()
=> Dans mois()
function jour()
=> Dans d_nais()
=> Dans mois()
=> Dans jour()
=> Sat Nov 07 1953 15:30:22 GMT+0100
Si c’est seulement pour obtenir l’affichage de la date, le plus important de ce script c’est la dernière
instruction (on désactive les autres instructions dans un bloc de commentaire) :
<script type="text/javascript">
function d_nais(an){
console.log("=> Dans d_nais()")
return function mois(ms,hr){
console.log("=> Dans mois()")
return function jour(jr,mn,sc){
console.log("=> Dans jour()")
return (
"=> "+new Date(an,ms-1,jr,hr,mn,sc)).toString();
}
}
}
/*
console.log(d_nais) // Affiche d_nais();
console.log(d_nais()) // Exécute d_nais et affiche mois();
console.log(d_nais()());
*/
console.log(d_nais(1953)(11,15)(7,30,22));
</script>
Ce qui est important dans le code ci-dessus, c’est le mode d’appel avec autant de parenthèses à partir de la fonction externe pour accéder à chaque niveau d’imbrication.
Une autre façon d’obtenir exactement la mêm chose :
<script type="text/javascript">
function d_nais(an){
mardi 31 juillet 2018
- 52 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
console.log("=> Dans d_nais()");
return function mois(ms,hr){
console.log("=> Dans mois()");
return function jour(jr,mn,sc){
console.log("=> Dans jour()");
return ("=> "+
new Date(an,ms-1,jr,hr,mn,sc)).toString();
}
}
}
// retourne adresse de mois()
v = d_nais(1953);
// appelle mois() qui retourne adresse de jour()
v = v(11,15);
// appelle jour() qui retourne le résultat
v = v(7,30,22);
console.log(v);
</script>
Exécution :
=> Dans d_nais()
=> Dans mois()
=> Dans jour()
=> Sat Nov 07 1953 15:30:22 GMT+0100
On peut faire s’enchaîner des fonctions plus internes :
<script type="text/javascript">
function d_nais(an){
console.log("=> Dans d_nais()");
return function mois(ms,hr){
console.log("=> Dans mois()");
return function jour(jr,mn,sc){
console.log("=> Dans jour()");
return ("=> "+
new Date(an,ms-1,jr,hr,mn,sc)).toString();
}
}
}
// retourne adresse de mois()
v = d_nais(1953);
// On peut enchaîner des fonctions plus internes
// appelle mois() puis jour() qui retourne le résultat
v = v(11,15)(7,30,22);
mardi 31 juillet 2018
- 53 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
// appelle jour() qui retourne le résultat
// v=v(7,30,22)
console.log(v);
</script>
Même Exécution :
=> Dans d_nais()
=> Dans mois()
=> Dans jour()
=> Sat Nov 07 1953 15:30:22 GMT+0100
Kinshasa, le jeudi 29 août 2019 (4:53:20 PM4:53 ).
Mots-clés :
fonctions,curry,currying,redéfinition,fonction fermeture,closure,paramètre
du reste,blocs de code,réutilisables,fonctions nommées,fonctions anonymes,expressions de fonctions immédiatement invoquées,eventHandler,affecter,variable,pointeur,script,types de fonction,syntaxes de fonction.
Mercredi, 11. avril 2018 (23:34 [pm]).
Dernière mise à jour : jeudi 29 août 2019 (4:53:20 PM).
DIASOLUKA Nz. Luyalu
Docteur en Médecine, Chirurgie & Accouchements (1977),
CNOM : 0866 - Spécialiste en ophtalmologie (1980)
Informaticien-amateur, Programmeur et WebMaster.
Chercheur indépendant, autonome et autofinancé, bénévole,
sans aucun conflit ou lien d’intérêt 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é.
mardi 31 juillet 2018
- 54 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
+243 - 851278216 - 899508675 - 995624714 - 902263541 - 813572818
[email protected]
Autre Lecture :
https://www.scribd.com/document/374738470/Le-Plus-Grand-Secret-deLa-Creation
D’autres publications pouvant aussi intéresser :
https://www.academia.edu/39781606/Calcul_Automatique_de_la_Date_de_votr
e_Création_lOvulation_la_Fécondité_et_de_lAccouchement
https://www.academia.edu/39700118/Quand_lordinateur_se_trompe_Quand_lin
formatique_dit_faux_
https://www.academia.edu/39672169/LES_DANGERS_DES_THERMOMÈTR
ES_NON-_CONTACT_À_INFRAROUGE_
https://www.academia.edu/38847663/Mieux_Analyser_et_Gérer_la_Tension_A
rtérielle_TA_Recherche_et_Meilleure_prise_en_charge
https://www.academia.edu/38786226/FICHE_DANALYSE_DE_LA_VISION_
DUN_MALADE
https://www.academia.edu/38786152/Comprendre_Facilement_la_Notion_de_
Dimensions_Multiples
https://www.academia.edu/38785943/Importance_du_dépistage_des_insuffisan
ces_visuelles
https://www.academia.edu/38566762/Répartition_Automatique_des_Billets_de
_Banque.docx
https://www.academia.edu/38566238/ITÉRATEUR_DÉNUMÉRABLES_GÉN
ÉRATEUR_YIELD_ET_NEXT.docx
mardi 31 juillet 2018
- 55 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
https://www.academia.edu/38536715/OUTILS_DE_DÉVELOPPEMENT_DE_
DIFFÉRENTS_BROWSERS.docx
https://www.academia.edu/38536714/Gestions_de_paramètres_et_nom_de_fon
ctions_-_Javascript_tome_xxiii
https://www.academia.edu/38536713/this_and_fonctions__javascript_tome_vi_-_PAS_PRET
https://www.academia.edu/38536711/Les_fonctions_en_JavaScript-II
https://www.academia.edu/38536710/Bref_Aperçu_sur_Les_Objets_en_JavaSc
ript_-_Javascript_tome_vii
https://www.academia.edu/38536709/Les_fonctions_en_JavaScript.docx
https://www.academia.edu/38536708/jeu_de_couleurs_javascript
https://www.academia.edu/38536707/Propriétés_d_objets_et_leurs_Attributs_et
_Pseudo-Classes_-_JavaScript
https://www.academia.edu/38536706/Quelques_Caractéristiques_du_MODE_S
TRICT_-_Javascript_tome_iii
https://www.academia.edu/38536705/sets_and_weaksets_-_javascript
https://www.academia.edu/38536704/RegExp_-_javascript_tome_x
https://www.academia.edu/38536703/Paramètres_du_Reste_-_Javascript
https://www.academia.edu/38536702/Couleurs_HTML_RGB_-_Javascript
https://www.academia.edu/38536701/maps_and_weakmaps_-_javascript
https://www.academia.edu/38536699/CLASSES_en_JavaScript__javascript_tome_iii
https://www.academia.edu/38536698/Quelques_caractéristiques_du_Mode_Stri
ct_-_javascript_tome_iii
mardi 31 juillet 2018
- 56 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
https://www.academia.edu/38536697/Prototype_en_JavaScript__javascript_tome_xvii
https://www.academia.edu/38536696/Codes_de_programme_pour_Quelques_A
PPLICATIONS_PRATIQUES_de_JavaScript_-_javascript_tome_viii
https://www.academia.edu/38536626/Le_Type_Number_-_javascript_tome_iii
https://www.academia.edu/38536152/Petite_Introduction_aux_PseudoElements_HTML
https://www.academia.edu/38536151/Lacuité_visuelle_Angulaire
https://www.academia.edu/38536150/SCRIPT_DANALYSES_DES_RÉFLEX
ES_PUPILLOMOTEURS.pdf
https://www.academia.edu/38536149/IMC_selon_Dr_DIASOLUKA.docx
https://www.academia.edu/38536148/Lacuité_visuelle_angulaire.docx
https://www.academia.edu/38536147/Itérations_-_javascript_tome_iv
https://www.academia.edu/38536146/nouveau_critere_de_performance_physiq
ue_en_fonction_de_lage.docx
https://www.academia.edu/38536145/1er_postulat_du_Dr_Diasoluka.docx
https://www.academia.edu/38536144/2e_postulat_du_Dr_Diasoluka.docx
https://www.academia.edu/38536143/Programme_de_Conversion_des_Unités_
des_Lunettes_III
https://www.academia.edu/38536142/Aléas_des_Appareils_Médicaux_de_Mes
ures.docx
https://www.academia.edu/38536141/Le_Laboratoire_Médical_nest_pas_laffair
e_de_tous
https://www.academia.edu/38536140/mode_demploi_mardi 31 juillet 2018
- 57 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
_Programme_d_equivalences_d_une_prescription_de_lunettes.pdf
https://www.academia.edu/38536139/programme_de_conv_unités_lun.pdf
https://www.academia.edu/38536138/ProgrammeIII_déquivalences_dune_prescription_de_lunettes.pdf
https://www.academia.edu/38536137/IMC_selon_Dr_DIASOLUKA.pdf
https://www.academia.edu/38536136/acuite_visuelle_nvelle_convention_notati
onnelle_normalisee.ppt
https://www.academia.edu/38536135/CoEnzyme_Q10_ou_CoQ10.docx
https://www.academia.edu/38536134/Aléas_dun_Voyage_Habité_vers_la_Plan
ète_Mars
https://www.academia.edu/38536133/objet_Image.docx
https://www.academia.edu/38536132/Nouvelle_Classification_du_Ptérygion.pp
tx
https://www.academia.edu/38536131/la_vraie_nature_du_soleil.pdf
https://www.academia.edu/38536130/model_macroscopique_dintrication_quant
ique
https://www.academia.edu/38536129/LINTRICATION_QUANTIQUE_ENCO
RE_MIEUX_ILLUSTRÉE-issuu.pdf
https://www.academia.edu/38536128/Fonctions_imbriquées_en_JavaScript__javascript_tome_vi
https://www.academia.edu/38536127/la_vraie_nature_du_soleil-issuu.pdf
https://www.academia.edu/38536126/Destructuration_and_paramètres__javascript_tome_xxi
https://www.academia.edu/38536125/LES_EBEs_Extra-terrestres_ressemblentmardi 31 juillet 2018
- 58 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
ils_aux_humains
https://www.academia.edu/38536123/Format_Représentation_interne_des_obje
ts_JavaScript_-_javascript_tome_ix
https://www.academia.edu/38536122/Lelement_anchor_en_JavaScript.docx
https://www.academia.edu/38536121/this_dans_différents_contextes__javascript_tome_v
https://www.academia.edu/38536120/Miscellaneous-Miscellanées__javascript_tome_viii
https://www.academia.edu/38536119/Lobjet_syntaxError__javascript_tome_xiv_-_PAS_PRET.docx
https://www.academia.edu/38536118/Date_Date_new_Date_et_new_Date__JavaScript
https://www.academia.edu/38536117/La_CONSOLE_-_javascript_tome_xiv__PAS_PRET.docx
https://www.academia.edu/38536116/Promises_en_JavaScript__javascript_tome_xxiii
https://www.academia.edu/38536115/Objets_Math_et_Number__javascript_tome_viii
https://www.academia.edu/38536114/javascript_tome_v.docx
https://www.academia.edu/38536113/kilo_mega_giga_tera.xlsx
https://www.academia.edu/38536112/Accessibilité_déléments_dArray_en_Java
Script_-_javascript_tome_xxii
https://www.academia.edu/38536111/Catalogue_des_Propriétés_des_objets_Na
tifs_-_javascript_tome_xx
https://www.academia.edu/38536110/Propriétés_de_HTMLElement__javascript_tome_xvi
mardi 31 juillet 2018
- 59 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
https://www.academia.edu/38536109/Littérales_de_chaîne_-_javascript
https://www.academia.edu/38536108/RegExp_-_javascript_tome_x
https://www.academia.edu/38536107/sets_and_weaksets_-_javascript
https://www.academia.edu/38536106/Paramètres_du_reste_-_javascript
https://www.academia.edu/38536105/Couleurs_html_RGB_-_javascript
https://www.academia.edu/38536104/maps_and_weakmaps_-_javascript
https://www.academia.edu/38536103/classes_-_javascript_tome_iii
https://www.academia.edu/38536102/Quelques_applications_pratiques_de_Jav
aScript_-_javascript_tome_viii
https://www.academia.edu/38536101/Prototype_en_JavaScript__javascript_tome_xvii
https://www.academia.edu/38536100/OUTILS_DE_DÉVELOPPEMENT_DE_
DIFFÉRENTS_BROWSERS.docx
https://www.academia.edu/38536099/Gestions_de_paramètres_et_nom_de_fon
ctions_-_javascript_tome_xxiii
https://www.academia.edu/38536098/petite_introduction_aux_fonctions_JavaS
cript-II.docx
https://www.academia.edu/38536097/this_and_fonctions__javascript_tome_vi_-_PAS_PRET
https://www.academia.edu/38536096/petite_introduction_aux_fonctions_JavaS
cript.docx
https://www.academia.edu/38536095/Jeu_de_couleurs_-_javascript
https://www.academia.edu/38536094/Bref_Aperçu_sur_Les_Objets_en_JavaSc
ript_-_javascript_tome_vii
mardi 31 juillet 2018
- 60 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
https://www.academia.edu/38536093/Propriétés_d_objets_et_leurs_attributs__javascript_tome_xvi
https://www.academia.edu/38536092/Associated_arrays_-_javascript
https://www.academia.edu/38536091/Quelques_caractéristiques_du_mode_stric
t_-_javascript_tome_iii
https://www.academia.edu/38536090/Lobjet_arraybuffer_-_javascript
https://www.academia.edu/38536089/tests_conditionnels_-_javascript_tome_v
https://www.academia.edu/38536088/Events_-_javascript_tome_viii
https://www.academia.edu/38536087/Application_rgb_rgba_hsl_hsla__javascript
https://www.academia.edu/38536086/Comment_utiliser_JavaScript_.docx
https://www.academia.edu/38536085/Object.defineProperties_-_JavaScript
https://www.academia.edu/38536084/Apply_bind_borrow_call__javascript_tome_iv
https://www.academia.edu/38536083/Petite_Introduction_aux_LIENS_HTML2
https://www.academia.edu/38536082/INPUTS_and_and_OUTPUTS__javascript_tome_xx
https://www.academia.edu/38536081/FONCTIONS_ANONYMES_fanon_
https://www.academia.edu/38536080/CLOSURES_CURRYING__javascript_tome_xiii
https://www.academia.edu/38536079/String_-_javascript_tome_xxii
https://www.academia.edu/38536078/Les_strings_-_javascript
mardi 31 juillet 2018
- 61 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
https://www.academia.edu/38536077/Arrays_en_JavaScript__javascript_tome_xv
https://www.academia.edu/38536076/Différents_types_dArrays_-_javascript
https://www.academia.edu/38536075/ITÉRATEUR_DÉNUMÉRABLES_GÉN
ÉRATEUR_YIELD_ET_NEXT.docx
https://www.academia.edu/38536074/Lélément_SELECT_en_HTML_XHTML
_DOM_JavaScript
https://www.academia.edu/38536073/Get_Set_Getter_and_Setter_en_JavaScrip
t.docx
https://www.academia.edu/38536072/Le_type_Number_-_javascript_tome_iii
https://www.academia.edu/38536070/javascript_and_algorithmique_3_.docx
https://www.academia.edu/38536068/Le_Type_Primitif_Symbol__javascript_tome_viii
https://www.academia.edu/38536066/Petite_Introduction_à_HTML_-_I
https://www.academia.edu/38536065/Création_dobjet_dans_lespace_globale_
Window_-_javascript_tome_viii
https://www.academia.edu/37815644/Nouvelle_Classification_du_Pterygion
https://www.academia.edu/39781647/Calcul_de_la_Date_de_lOvulation
https://www.academia.edu/26131680/Incongruences_Hérésies_et_Hétérodoxies
_de_la_Notion_de_Laboratoire
https://www.academia.edu/26130044/RAPPORT_ENTRE_OXYMÉTRIE_ET_
TYPE_RESPIRATION
https://www.academia.edu/37815660/acuite_visuelle_nvelle_convention_notati
onnelle_normalisee
mardi 31 juillet 2018
- 62 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
https://www.academia.edu/37815613/medicaments_plus_nocifs_quutiles
https://www.academia.edu/39700864/Les_objets_Proxy_et_Reflect_JAVASCRI
PT
https://www.academia.edu/39700336/Quand_lordinateur_se_trompe_Quand_lin
formatique_ne_dit_pas_vrai_
https://www.academia.edu/39672297/DANGERS_and_RISQUES_DES_THER
MOMÈTRES_NON-CONTACT_à_INFRAROUGE_
https://www.academia.edu/39672133/LE_DOSAGE_DES_MÉDICAMENTS_
AVEC_DES_CUILLERS_EST_HASARDEUX
https://www.academia.edu/39671602/Pelvimétrie__ÉVALUATION_DU_RISQUE_DE_LACCOUCHEMENT_DYSTOCIE_OSS
EUSE_
https://www.academia.edu/39637192/Anomalies_de_la_Vision_Des_Couleurs_
Avez-vous_un_Problème_de_la_Perception_des_Couleurs
https://www.academia.edu/39636203/Simulateur_Logiciel_de_LAnomaloscope
_de_Nagel
https://www.academia.edu/39514787/Some_Constraints_Of_Progressive_Lense
s_Optométrie
https://www.academia.edu/39329775/Code_de_programme_pour_multiplier_de
ux_nombres_entiers
https://www.academia.edu/39265617/spectral_sensitivity_of_the_human_eye
https://www.academia.edu/39263331/Vision_Des_Couleurs_Vision_colorée_Av
ez-vous_un_Problème_de_la_Perception_des_Couleurs
https://www.academia.edu/39043806/Les_Propriétés_innerText_-innerHTML_outerHTML_textContent_JAVASCRIPT_Programmation_Internet_VOL._XXIV
https://www.academia.edu/39036138/Logiciel_de_Scrutin_remplaçant_la_mac
mardi 31 juillet 2018
- 63 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
hine_à_voter
https://www.academia.edu/39019044/Utilitaire_javascript_des_RDVs_et_autres
_délais_version_6.0
https://www.academia.edu/39000281/Code_calculant_automatiquement_les_pa
ramètres_cruciaux_de_la_TA_MPM_PAM_PAM2_dPAM
https://www.academia.edu/38980659/Appli_pour_fixer_automatiquement_les_
RDVs_et_autres_délais_version_3
https://www.academia.edu/38971497/Une_Conséquence_fâcheuse_des_lentille
s_de_Contact_Verres_de_Contact_
https://www.academia.edu/38961397/Code_de_programme_pour_vérifier_la_d
euxième_méthode_de_multiplication_de_deux_nombres_entiers
https://www.academia.edu/38882972/Lultime_révélation_sur_la_Création_Croi
ssance_Biologique_des_Chiffres
https://www.academia.edu/38881707/Encore_Une_autre_méthode_de_multipli
cation
https://www.academia.edu/38566676/Les_objets_Object_et_Reflect__javascript_tome_viii
https://www.academia.edu/38536071/OPÉRATEURS_D_ÉGALITÉ__javascript_tome_xi
https://www.academia.edu/38536069/Variables_Functions_et_Nouveautés_en_J
avaScript_-_JavaScript_tome_ii
https://www.academia.edu/38536064/Lobjet_global_window__javascript_tome_vii
https://www.academia.edu/39516235/Dieu_est_le_chef_de_christ
https://www.academia.edu/39516056/À_Combien_Pourraiton_Vendre_lUnivers_Entier_
mardi 31 juillet 2018
- 64 / 65 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
https://www.academia.edu/39515968/Limportance_biblique_du_manger
https://www.academia.edu/39407150/La_Sainte_Bible_nest_quun_recueil_de_l
essentiel_à_connaître
https://www.academia.edu/38536067/Incongruences_Hérésies_et_Hétérodoxies
_des_Laboratoires_Médicaux
https://www.academia.edu/39906187/Une_autre_façon_danalyser_la_T.A._ave
c_la_Systolique_et_la_Diastolique_Cardio-Vasculaire
https://www.academia.edu/39873996/Code_de_programme_pour_détecter_Ass
ociation_médicamenteuse_cumulative
https://www.academia.edu/39872528/LE_SYSTÈME_DE_GOUVERNANCE_
QUI_CONVIENDRAIT_LE_MIEUX_POUR_LA_RÉPUBLIQUE_DÉMOCR
ATIQUE_DU_CONGO_États_Autonomes_Solidaires_Unifiés_
mardi 31 juillet 2018
- 65 / 65 -
23:12:45 [PM]
Téléchargement
Explore flashcards