Une autre utilité, les variables statiques
Nous venons de voir un cas d'utilisation des closures. Cependant, leur utilisation ne se limite pas uniquement à ce cas de figure, elles permettent de résoudre de nombreux casse-têtes en Javascript. Un cas provoquant assez souvent quelques prises de tête dans ce langage est l’inexistence d'un système natif de variables statiques.
Si vous avez déjà codé avec quelques autres langages, vous avez probablement déjà étudié les variables statiques. En C, elles se présentent sous cette forme :
void myFunction() { static int myStatic = 0; } |
Ces variables particulières sont déclarées à la première exécution de la fonction, mais ne sont pas supprimées à la fin des exécutions. Elles sont conservées pour les prochaines utilisations de la fonction.
Ainsi, dans ce code en C, la variable myStatic est déclarée et initialisée à 0 lors de la première exécution de myFunction(). La prochaine exécution de la fonction ne déclarera pas de nouveau cette variable, mais la réutilisera avec la dernière valeur qui lui a été affectée.
En gros, c'est comme si vous déclariez une variable globale en Javascript et que vous l'utilisiez dans votre fonction : la variable et sa valeur ne seront jamais détruites. En revanche, la variable globale est accessible par toutes les fonctions, tandis qu'une variable statique n'est accessible que pour la fonction qui a fait sa déclaration.
En Javascript, nous pouvons faire ceci :
var myVar = 0;
function display(value) {
if(typeof value != 'undefined') { myVar = value; }
alert(myVar);
}
display(); // Affiche : 0 display(42); // Affiche : 42 display(); // Affiche : 42 |
Alors que nous voudrions arriver à ceci afin d'éviter l'accès à myVar par une fonction autre que display():
function display(value) {
static var myVar = 0;
if(typeof value != 'undefined') { myVar = value; }
alert(myVar);
}
display(); // Affiche : 0 display(42); // Affiche : 42 display(); // Affiche : 42 |
Je viens de voir que le mot-clé static existe en Javascript, pourquoi ne pas l'utiliser ?
Ah oui ! Il s'agit d'une petite incohérence (de plus) en Javascript. Il faut savoir que ce langage a réservé de nombreux mots-clés alors qu'ils lui sont inutiles. Le mot-clé static en fait partie. Autrement dit, il est réservé, mais ne sert à rien et n'a donc aucune influence sur votre code (mis à part le fait de générer une erreur).
La solution se trouve donc avec les closures. En respectant le schéma classique d'une closure, une IEF avec une fonction anonyme à l'intérieur, nous pouvons déclarer une variable dans l'IEF et ainsi elle ne sera utilisable que par la fonction anonyme et ne sera jamais supprimée :
(function() {
var myVar = 0;
function() { // Du code… }
})(); |
Cependant, comment accéder à notre fonction anonyme ? La solution est simple : en la retournant avec le mot-clé return et en passant sa référence à une variable :
var myFunction = (function() {
var myVar = 0;
return function() { // Du code… };
})(); |
Si nous reprenons notre exemple, mais adapté de manière à ce qu'il possède une variable statique, alors nous obtenons ceci :
var display = (function() {
var myVar = 0; // Déclaration de la variable pseudo-statique
return function(value) {
if(typeof value != 'undefined') { myVar = value; }
alert(myVar);
};
})();
display(); // Affiche : 0 display(42); // Affiche : 42 display(); // Affiche : 42 |
Et voilà une fonction avec une variable statique nommée myVar ! Cela pourra vous être utile par moments (bien que cela soit assez rare).
Créé avec HelpNDoc Personal Edition: Générateur facile de livres électroniques et documentation