Les fonctions en JavaScript

Petite Introduction Aux
Fonctions JavaScript
Les fonctions sont des « blocs de code » réutilisables qu’on peut
appeler n’importe quand et de n’importe où dans un programme.
Il existe des fonctions nommées qu’on peut appeler de n’importe
où, et des fonctions anonymes qu’on peut exécuter (invoquer)
juste à la fin de leur définition (expressions de fonctions immédiatement invoquées) ou utiliser comme event Handler ou qu’on peut affecter à une variable (soit la valeur qu’elle retourne, soit son
adresse = pointeur).
Le petit script ci-dessous illustre différents types et syntaxes de
fonctions.
<script type="text/javascript"> "use strict;"
// Syntaxe ordinaire d'une fonction
function f0(v=1){console.log(Math.tan(v))};
f0(); // 1.5574077246549023
/******************************/
let f1=(function(){return Math.tan(1)})();
//
Petite Introduction Aux Fonctions JavaScript
// f1 reçoit ici la VALEUR DE RETOUR de la
// fonction anonyme, car cette fonction anonyme
// est immédiatement exécutée (invoquée) à ause des
// parenthèses qui termient sa définition/déclaration.
// Mais ici les parenthèses entourant la
// définition/déclaration de la fonction anonyme
// ne sont pas indispensables car affectation.
console.log(f1); // 1.5574077246549023
// console.log(f1());
//
// TypeError: f1 is not a function
// f1();
// TypeError: f1 is not a function
/******************************/
let f2=function(){return Math.tan(v)}(v=1);
//
// f2 reçoit ici la valeur de retour de
// la fonction anonyme.
console.log(f2); // 1.5574077246549023
/******************************/
let f3=function(v=1){return Math.tan(v)};
console.log(f3()); // 1.5574077246549023
mardi 31 juillet 2018
- 2/13 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
let f4=function(v=123){console.log(Math.tan(v))};
f4(Math.log(Math.E)); // 1.5574077246549023
/*****************************/
// function(){console.log(Math.tan(1)}();
//
// Ici les parenthèses autour de la fonction
// sont obligatoires.
// SyntaxError: function statement requires a name
// Mais on peut immédiatement invoquer la fonction
// anonyme en la faisant précéder d'un opérateur,
// ou bien entendu, l'entourer de parenthèses.
+function(){console.log(Math.tan(1))}();
// 1.5574077246549023
!function(){console.log(Math.tan(1))}();
// 1.5574077246549023
-function(){console.log(Math.tan(1))}();
// 1.5574077246549023
~function(){console.log(Math.tan(1))}();
// 1.5574077246549023
`${function(){console.log(Math.tan(1))}()}`;
// 1.5574077246549023
+(_=>console.log(Math.tan(1)))();
// 1.5574077246549023
mardi 31 juillet 2018
- 3/13 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
~((v=1)=>console.log(Math.tan(v)))();
// 1.5574077246549023
(function(){console.log(Math.tan(1))}());
// 1.5574077246549023
//
// Ici les parenthèses autour de la fonction
// sont obligatoires.
// SyntaxError: function statement requires a name
(function(){console.log(Math.tan(1))})();
// 1.5574077246549023
//
// Ici les parenthèses autour de la fonction
// sont obligatoires.
// SyntaxError: function statement requires a name
/*****************************/
let f5=function(){console.log(Math.tan(1))};
//
// Ici, il s'agit aussi d'une fonction anonyme
// On ne peut pas l'appeler par son nom.
// Mais la vaviable f3 reçoit (pointe) L'ADRESSE
// de la fonction anonyme qui n'est pas
// immédiatement invoquée.
// On peut donc appeler la fonction anonyme
// indirectement via son adresse stockée dans
// la variable f3
f5(); // 1.5574077246549023
let f6=_=>console.log(Math.tan(1));
mardi 31 juillet 2018
- 4/13 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
f6()
/*****************************/
// LE PARAMÈTRE DU RESTE
let f7=function(p1,p2,...p3){
console.log(p1,p2,p3);
}
f7("dias",2018,"puis,",["paramètre","du"],{p:"reste"})
// dias 2018 Array [ "puis,", […], {…} ]
// dias 2018 […]
//
0: "puis,"
//
1: Array [ "paramètre", "du" ]
//
2: Object { p: "reste" }
//
length: 3
//
__proto__: Array []
/*****************************/
function ext(rayon){
let vLocExt=Math.PI;
vLocExt*=10;
const c=rayon
const ds="Dans ext, "
// fonction fermeture (closure)
const fClosure=function(intro){
return ds+intro+" "+vLocExt*Math.pow(c,2)
}
mardi 31 juillet 2018
- 5/13 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
return ["avec",fClosure]
}
// CURRYING
const cv=ext(3);
let cr
cr=cv[1](cv[0])
console.log("Surf=",cr)
// Surf= Dans ext, avec 282.7433388230814
console.log(Math.PI*10*3*3)
// 282.74333882308133
</script>
Rappel : le caractère ` est le code ASCII 096, obtensible avec <ALT-096>.
mardi 31 juillet 2018
- 6/13 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Redéfinition de fonction :
En JavaScript aussi bien en mode standard qu'en mode strict, une fonction peut
être redéfinie, pouvant engendrer de graves erreurs de temps d'exécution (omissions d'exécution) pouvant passer inaperçues, avec les contraintes suivantes:
1. Une DÉFINITION de fonction et APPEL de fonction
fonction.
<script language="JavaScript"> "use strict";
function factor(n){
if(n==1)return 1
else return n*factor(n-1)
}
console.log(factor(10))
// 3628800
</script>
2. On pourrait croire que la dernière fonction redéfinie devrait prendre effet à
l'endroit de la redéfinition jusqu'à la fin de l'exécution du programme ou une
nouvelle redéfinition, écrasant ou se substituant à toute définition antérieure.
Mais méfiez-vous parfois des apparences !
<script language="JavaScript"> "use strict";
function factor(n){
console.dir("Ceci ne calcule pas la factorielle")
}
function factor(n){
if(n==1)return 1
else return n*factor(n-1)
mardi 31 juillet 2018
- 7/13 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
}
console.dir(factor(20))
// 2432902008176640000
</script>
3. Une définition de fonction reste active tant qu'une autre fonction portant le
même nom n'a pas encore été redéfinie dans le code source DANS UN AUTRE
BLOC DE SCRIPT.
<script language="JavaScript"> "use strict";
function factor(n){
console.dir("Ceci ne calcule pas la factorielle")
}
factor(6)
// Ceci ne calcule pas la factorielle
</script>
<script>
console.log("REDÉFINITION DANS UN AUTRE BLOC DE SCRIPT")
</script>
<script language="JavaScript"> "use strict";
function factor(n){
if(n==1)return 1
else return n*factor(n-1)
}
console.dir(factor(21))
// 51090942171709440000
</script>
mardi 31 juillet 2018
- 8/13 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Exécution :
Ceci ne calcule pas la factorielle
test.html:3:1
REDÉFINITION DANS UN AUTRE BLOC DE SCRIPT
test.html:11:1
51090942171709440000
test.html:20:1
4. Si la redéfinition de fonction se fait dans UN MÊME BLOC DE SCRIPT c'est la
dernière définition de la fonction ayant le même nom qui sera active (qui exécutera) et avant cette dernière redéfinition la première définition ne sera même
pas appelée.
<script language="JavaScript"> "use strict";
function factor(n){
console.dir("Ceci ne calcule pas la factorielle")
}
factor(6) // N'appelle même pas !
// Notez aussi que toutes les [re]définitions sont
// dans un même élément SCRIPT.
console.log("REDÉFINITION DANS UN AUTRE BLOC DE SCRIPT")
function factor(n){
if(n==1)return 1
else return n*factor(n-1)
}
console.dir(factor(170))
// 7.257415615307994e+306
</script>
Exécution :
mardi 31 juillet 2018
- 9/13 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
REDÉFINITION DANS UN AUTRE BLOC DE SCRIPT
test.html:10:1
7.257415615307994e+306
test.html:17:1
5. Remarquez ci-dessous que sans la redéfinition, la première définition est bel et
bien appelée.
<script language="JavaScript"> "use strict";
function factor(n){
console.dir("Ceci ne calcule pas la factorielle")
}
factor(150)
// Ceci ne calcule pas la factorielle
test.html:3:3
console.log("REDÉFINITION DANS UN MÊME BLOC DE SCRIPT")
// REDÉFINITION DANS UN MÊME BLOC DE SCRIPT
test.html:10:1
/*
function factor(n){
if(n==1)return 1
else return n*factor(n-1)
}
*/
console.dir(factor(100))
// Ceci ne calcule pas la factorielle
test.html:3:3
// undefined
test.html:20:1
</script>
Exécution :
Ceci ne calcule pas la factorielle
mardi 31 juillet 2018
- 10/13 -
test.html:3:3
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
REDÉFINITION DANS UN MÊME BLOC DE SCRIPT
test.html:10:1
Ceci ne calcule pas la factorielle
test.html:3:3
undefined
test.html:20:1
mardi 31 juillet 2018
- 11/13 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Mots-clés :
fonctions
fonctions,curry,currying,redéfinition,fonction fermeture,closure,paramètre du
reste,blocs de code,réutilisables,fonctions
fonctions nommées
nommées,fonctions
fonctions an
ano
onymes
nymes,expressions de fonctions immédia
immédiatement
tement inv
invo
oquées,eventHandler
eventHandler
eventHandler,affecter,variable,pointeur,script,types de fonction,syntaxes de fonction.
Mercredi, 11. avril 2018 (23:34 [pm]).
Dernière mise à jour : 31 juillet 2018 (23:02 [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é.
+243 - 851278216 - 899508675 - 995624714 - 902263541 - 813572818
diasfb@
[email protected]
mail2world.com
Autre Lecture :
https://www.scribd.com/document/374738470/Le-Plus-Grand-Secret-deLa-Creation
D’autres publications pouvant aussi intéresser :
• https://www.scribd.com/document/377036251/Le-Dosage-Des-Medicamentsen-Cac-Cas
• https://www.scribd.com/document/377035454/Le-Hasard-Des-Thermometresmardi 31 juillet 2018
- 12/13 -
23:12:45 [PM]
Petite Introduction Aux Fonctions JavaScript
Non-contact-a-Infrarouge
• https://www.scribd.com/document/376222482/Petite-Introduction-Aux-Fonctions-JavaScript
• https://www.scribd.com/document/376221919/La-Foi-en-Jesus-Christ-PourQuoi-Faire
• https://www.scribd.com/document/375689778/Lacuite-visuelle-angulaire
• https://www.scribd.com/document/375349851/La-variable-This
• https://www.scribd.com/document/375024162/Fonctions-Imbriquees-en-JS
• https://www.scribd.com/document/374789297/Format-Interne-Des-Objets-JavaScript
• https://www.scribd.com/document/374788758/Iterations-en-JavaScript
• https://www.scribd.com/document/374738470/Le-Plus-Grand-Secret-de-LaCreation
• https://www.scribd.com/document/374597969/Nouvelle-Formule-d-IMC-indice-de-doduite-Selon-Dr-Diasoluka
• https://www.scribd.com/document/373847209/Property-Descriptors
• https://www.scribd.com/document/373833282/l-Objet-Global-Window
• https://www.scribd.com/document/372665249/Javascript-Tome-II
• https://www.scribd.com/document/355291488/motilite-oculaire-2
• https://www.scribd.com/document/355291239/motilite-oculaire-I
• https://www.scribd.com/document/355290248/Script-d-Analyses-Des-Reflexes-Pupillomoteurs
• https://www.scribd.com/document/321168468/Renseignements-Id-et-Anthropometriques
• https://www.scribd.com/document/320856721/Emission-31-Jul-2016
• https://www.scribd.com/document/318182982/Complication-Visuelle-du-Traitement-de-La-Malaria
• https://www.scribd.com/document/318180637/Rapport-Entre-Oxymetrie-EtType-Respiration
• https://www.scribd.com/document/315746265/Classification-Des-Medicaments
• https://www.scribd.com/document/315745909/Incongruences-Heresies-et-Heterodoxies-de-la-Notion-de-Laboratoire
• https://www.scribd.com/document/315745725/Rapport-Entre-Oxymetrie-EtType-Respiration
mardi 31 juillet 2018
- 13/13 -
23:12:45 [PM]