Fonctions et Variables
Tutoriaux, Sommaire
JavaScript
On peut utiliser des variables dans une
fonction si celle-ci sont déclarées à l'extérieur de cette fonction,
c'était le cas dans la leçon précédente, les variables étaient toutes
déclarées dans l'en-tête du programme, donc globales. C'est plus clair pour
l'utilisation et évite certains problèmes que nous verrons dans cette leçon
mais n'est pas strictement indispensable.
En effet le fait d'affecter une variable comme,
q = 10
revient à définir la variable q, même si cette affectation
se fait à l'intérieur d'une fonction.
Function Essai(){
q = 10
//Instructions
.................
}
La variable q pourra être utilisée à l'intérieur et à
l'extérieur de la fonction Essai().
Nous avons vu que le nom de la fonction
était suivi de deux parenthèses pouvant contenir des variables. Ceci est
l'autre manière de passer des valeurs à une fonction. Exemple ,
var variableA
var variableB
function PassVariable(a, b){
//Utilisation des variables dans la
fonction
if(a < 0){
variableA = -
a
variableB = b
* 5
}
}
//Assignation des variables
variableA = -3
variableB = 101
//Appel de la fonction
PassVariable(variableA, variableB)
//Affichage des résultats
alert("variableA " + variableA + " variableB
" + variableB)
Dans la fonction PassVariable()
nous passons les deux variables variableA et variableB
respectivement aux variables locales a et b, par l'instruction,
PassVariable(variableA, variableB)
Nous pouvons vérifier en effectuant ce programme dans la
forme ci-dessous que puisque variableA est < 0,
(négative), on inverse le signe de variableA et on
multiplie variableB par 5.
Exercice, vérifiez que a et b sont locales à la fonction
PassVariable(), c'est à dire non défini à l'extérieur de celle ci. Essayez
d'utiliser la valeur a à l'extérieur de la fonction, dans le message alert().
Remplacez la variable variableA, (pas la chaîne de
caractères), par a. Corrigé . Explication
Il pourrait sembler plus simple de ne pas utiliser des
variables différentes à l'intérieur de la fonction, mais simplement
d'écrire,
function PassVariable(variableA,
variableB){
//Utilisation des variables dans la
fonction
if(variableA < 0){
variableA = -
variableA
variableB =
variableB * 5
}
}
Modifiez le contenu de la forme ci-dessus, (faites Code
initial avant pour corriger le message alert), ou faire Corrigé
Vous observerez que variableA et variableB
sont toujours à -3 et à 101 dans le message alert(), comme si la fonction
n'avait pas été effectuée. Vous pouvez inclure dans la fonction un message
alert pour vérifier sont fonctionnement, Corrigé,
vous pourrez vérifier que les valeurs de variableA et
variableB sont bien modifiées à l'intérieur de la fonction mais non
au-dehors. Même si elles portent le même nom que des variables globales, les
variables passées en argument dans une fonction sont redéfinies comme locales
pendant l'exécution de la fonction, comme si il s'agissait de variables tout à
fait différentes.
Dans le cas où l'on ne désire pas changer la valeur des
variables passées en argument à l'extérieur de la fonction, le problème
ci-dessus ne se pose pas, sinon passez par des variables locales comme a et b
dans le premier exemple.
Quand on passe des arguments à une
fonction, ceux-ci sont maintenus dans un tableau nommé arguments[i]. nous
verrons la manipulation de ce tableau ultérieurement
L'instruction return permet de retourner une valeur à
l'endroit où est appelée la fonction. exemple,
result = Carre(nombre)
Carre() est une fonction calculant la carré d'un nombre, si
cette fonction contient une instruction return retournant la valeur du carré de
nombre, Carre(nombre) sera remplacé par la valeur du carré de nombre dans
l'expression ci dessus.
Soit nombre = 12
result = Carre(nombre)
=> result = Carre(12)
=> result = 144
Syntaxe de la fonction Carre(),
function Carre(k){
//Calcul du carré
return k*k
}
Une telle fonction peut-être employée dans n'importe quelle
expression complexe, comme,
result = (Carre(nombre)/12)+100
Dans ce cas la fonction s'emploie comme une instruction,
(comme alert() par exemple).
Exercice, dans la forme ci-dessous, changer
la valeur de nombre.
Exercice, modifier la fonction pour calculer le cube,
(puissance 3), d'un nombre. Corrigé.
Exercice, écrire une expression complexe employant Carre()
A l'intérieur d'une fonction on peut appeler
une autre fonction. Si on prend l'exemple précédent, de la fonction Carre(),
on pourrait définir une fonction somme de carrés SommeCarre(), telle que
:
soit deux nombres i et j la fonction SommeCarre() renverrait
la somme i² + j²
function SommeCarre(i, j){
return Carre(i) + Carre(j)
}
Exercice, insérer la fonction SommeCarre() dans la forme
ci-dessus, appeler là en donnant deux valeurs numériques à i et j, afficher
le résultat dans une boite alert(). Corrigé
Dans une fonction on peut appeler une
autre fonction y compris elle-même, cette faculté s'appelle la récursivité.
Nous allons prendre l'exemple d'un calcul de factorielle.
La factorielle d'un nombre n est le produit des nombres de 1
à n, tel que 1 * 2 * 3 ..... (n-1) * n
Exemple,
factorielle 4 = 1 * 2 * 3 * 4 = 24
factorielle 6 = 1 * 2 * 3 * 4 * 5 * 6
= 720
Pour calculer la factorielle d'un nombre n, nous allons
écrire une fonction Factorielle(n), telle que,
result = (n * Factorielle(n-1))
return result
Nous voyons que dans cette expression nous rappelons la
fonction.
Processus,
Le calcul de la factorielle se
compose d'une ligne de calcul de la factorielle et d'une ligne return, (retour
du résultat d'un calcul intermédiaire). Si n = 4, à la première itération,
n = 4 nous avons donc dans result <= 4 * Factorielle(3)
Ce contenu de result n'est pas un
nombre mais une 
expression, il sera donc évalué et Factorielle(3) sera effectuée, nous
aurons à ce moment dans result, (2eme itération),
result <= 4 * ( 3 *
Factorielle(2))
3eme itération
result <= 4 * ( 3 * ( 2 *
Factorielle(1))
4eme itération, Factorielle(1) =>
1
result <= 4 * ( 3 * ( 2 * 1))
Il faudra arrêter là les itérations, à ce moment on peut
évaluer le contenu de result, (24). Dans le rappel de la fonction Factorielle()
nous voyons que n est décrémenté de 1 à chaque itération, l'arrêt des
itérations pourra se faire pour n = 1, on peut écrire,
function Factorielle(n) {
if (n < 2){
return 1
}else {
result = (n * Factorielle(n-1))
return result
}
}
Tant que n est plus grand 1, les itérations se poursuivent,
pour n < 2, (en fait 1), la dernière valeur d'itération est renvoyée, (1).
A ce moment la valeur de la factorielle est calculée et retournée à
l'instruction d'appel par exemple,
résultat = Factorielle(nombre)
