- Le cas des variables
- Les variables globales
- Les variables locales
Dans un programme, il arrive souvent que l’on est a executer les même instructions plusieurs fois de suites. Dans certains cas, on peut utiliser
une boucle. Mais dans d’autres, il peut être préférable de créer une fonction que l’on poura appeller par la suite en cas de besoin.
Pour créer une fonction, on utilise tout simplement function, suivit du nom de la fonction qui doit être un indentificateur valide, puis des
parenthèses et enfin des très célébres accolades.
Passons pour le moment sur les parenthèses. La fonction proprement dite se trouve entre les accolades. Voici un exemple de fonction :
function Hello(){// Ceci est une fonction
document.write("Hello! Visiteur!<br>");
document.write("Ça va bien aujourd'hui ?<br>");
}
Cette fonction peut ensuite être appelée tout simplement en utilisant son nom (ici, Hello) :
function Hello(){
document.write("Hello! Visiteur!<br>");
document.write("Ça va bien aujourd'hui ?<br>");
}
Hello();// Appel de la fonction Hello
Dès que l’interpreteur va rencontrer Hello(), il va executer les instructions comprises dans cette même fonction.
Comme ceci, une fonction est plutôt limitée. Mais on peut lui adjoindre des arguments. Par exemple, lorsque vous utiliser la méthode write
de l’objet document, vous lui donner un argument qui est la chaîne de caractères à écrire.
Les arguments doivent être donnés entre les parenthèses de la fonction, sous forme de variables. Ces variables peuvent ensuite être utilisées dans
la fonction :
function Hello(nom, temps){// 2 arguments : nom et temps
document.write("Hello! " + nom + "!<br>");
document.write("Voici le temps : " + temps + "<br>");
}
Cette fonction peut ensuite être appelée comme n’importe quel autre fonction, à condition de lui passer des arguments (sinon, les variables seront
indefinies (undefined) et les conséquences peuvent être indésirables).
function Hello(nom, temps){
document.write("Hello! " + nom + "!<br>");
document.write("Voici le temps : " + temps + "<br>");
}
Hello("Francky", "Beau soleil");
Hello("Jo", "Maussade");
Contrairement à d’autres langages, JavaScript ne peut pas modifier les variables par référence. Nous ne nous avancerons donc pas plus sur ce sujet.
Les fonctions, quelles aient des arguments ou pas, ont toutes accès à un tableau nommé arguments. Dans ce tableau sont répertoriés tous
les arguments passés à la fonction. Cela permet d’apporter plus ou moins un certain dynamisme au fonction. Voici un exemple :
function Args(){// Pas d'arguments...
for(var i=0; i < arguments.length; i++){// ...et pourtant !
document.write("Argument N°" + i + " " + arguments[i] + "<br>");
}
}
Args("Un argument", "2 arguments", "3 arguments");
Une fonction peut également retourner une valeur. On utilise pour cela l'instruction return à l'interieur de celle-ci, suivit de la valeur
à retourner. Une fois que l'interpréteur à rencontré l'instruction return, toutes les instructions qui peuvent suivre ne sont pas executées
car la fonction est quitée.
Exemple :
function Volume(longueur, largeur, hauteur){
return longueur * largeur * hauteur;
}
document.write("Le volume d'une boite de 10x15x20 est de " + Volume(10, 15, 20));
On ne le cache pas depuis le début, JavaScript est directement issu de Java. Mais il est également doté d'un spectaculaire dynamisme. On peut par
exemple affecter une fonction à une variable, comme dans l'exemple suivant :
function Volume(longueur, largeur, hauteur){
return longueur * largeur * hauteur;
}
var MonVolume = Volume;
document.write("Le volume d'une boite de 10x15x20 est de " + MonVolume(10, 15, 20));
On peut aussi créer des fonction littéralement, comme pour les tableaux :
var HelloBis=function(){
document.write("Re-bonjours, les amis!<br>");
document.write("Me re-voila dans une fonction littéral");
}
HelloBis();
Une dernière possibilité est d'utiliser le constructeur Function. Function prend pour arguments les noms des arguments que la fonction
va utiliser (séparés par des virgules, autant de fois que necessaire), et comme dernier argument, les instructions a executer :
var Bonjour=new Function("nom", "document.write('Hello, ' + nom + '! Tu vas bien ')");
Bonjour("Paul");
Le cas des variables
L'accés aux variables par une fonction est soumis à certaines rêgle. Il faut alors distinguer ce que l'on appelle les variables globales et
les variables locales.
Les variables globales
Une variable globale est accessible par toutes les fonctions d'un script. Elle est déclarée comme d'habitude par le mot-clef var, à
l'exterieur des fonctions.
Les instructions situées ensuite à l'interieur des fonctions peuvent ensuite accéder à cette variable :
function MaFonction(){
MaVariable++;// Modification de la variable GLOBALE
}
var MaVariable=10;// Ceci est une variable GLOBALE
MaFonction();
document.write(MaVariable);// Sortie -> 11
Les variables locales
Un variable locales est accessible uniquement par les instructions de la fonction où celle ci est déclarée. Les autres fonctions ou le corps
principal du script ne peuvent pas l'utiliser. On déclare une variable locale comme d'habitude, avec le mot-clef var. Seulement, la
déclaration doit se trouver dans la fonction où la variable doit être locale (logique!) :
function FonctionBis(){
var MaVariable=10;// Ceci est une variable LOCALE
}
FonctionBis();// Appel à FonctionBis qui initialise
// la variable MaVariable
document.write(MaVariable);// !! ERREUR : Variable indéfinie !!
Il est souvent préférable d'avoir recours aux variables locales et au passage par arguments entre fonctions, plutôt que d'utiliser un grand nombre
de variables globales, souvent source de complication et d'erreur.
Un point cependant : et si une variable locale porte le même nom qu'une variable globale ?
Et bien c'est la variable locale qui a autorité :
function UneFonction(){
var MaVariable;
document.write(MaVariable);// Sortie -> undefined
}
var MaVariable = "Ceci est une variable globale";
UneFonction();
). Une
et hexadécimal (base 16).
Français 
English (Anglais)