Jetons un coup d'œil à l'objectif des fermetures. En fait, en utilisant des fermetures, nous pouvons faire beaucoup de choses. Par exemple, simulez le style de code orienté objet; Exprimez le code plus élégamment et de manière concise; et améliorer l'efficacité de l'exécution du code sous certains aspects.
1 fonction anonyme auto-exécutante
Nous savons que si toutes les variables ne sont pas ajoutées avec le mot clé VAR, la valeur par défaut sera ajoutée aux propriétés de l'objet global. Il existe de nombreux inconvénients à l'ajout de telles variables temporaires à l'objet global.
Par exemple: d'autres fonctions peuvent abuser de ces variables; Rendre l'objet global trop grand et affecter la vitesse d'accès (car la valeur de la variable doit être traversée de la chaîne prototype).
En plus d'utiliser le mot clé VAR chaque fois que nous utilisons la variable, nous rencontrons souvent une situation dans laquelle certaines fonctions ne doivent être exécutées qu'une seule fois et leurs variables internes n'ont pas besoin d'être maintenues.
Par exemple, dans l'initialisation de l'interface utilisateur, nous pouvons utiliser des fermetures:
La copie de code est la suivante:
var dataModel = {
tableau : [],
arbre : {}
};
(fonction (dm) {
pour (var i = 0; i <dm.Table.Rows; i ++) {
var row = dm.Table.Rows [i];
pour (var j = 0; j <row.cells; i ++) {
DrawCell (i, j);
}
}
// Construire DM.tree
}) (dataModel);
Nous créons une fonction anonyme et l'exécutons immédiatement, car les variables externes ne peuvent pas référencer les variables à l'intérieur,
Par conséquent, il sera publié peu de temps après l'exécution. La clé est que ce mécanisme ne polluera pas l'objet global.
2 cache
Prenons un autre exemple. Imaginez que nous avons un objet de fonction très long qui prend beaucoup de temps pour traiter chaque appel.
Ensuite, nous devons stocker la valeur calculée. Lorsque nous appelons cette fonction, nous recherchons d'abord dans le cache. S'il ne peut être trouvé, nous effectuerons le calcul.
Ensuite, mettez à jour le cache et renvoyez la valeur. S'il est trouvé, renvoyez simplement la valeur trouvée directement. La fermeture fait exactement cela, car elle ne publie pas de références externes,
Ainsi, la valeur à l'intérieur de la fonction peut être préservée.
La copie de code est la suivante:
var cachedsearchbox = (function () {
var cache = {},
count = [];
retour {
attachsearchbox: function (dsid) {
if (dsid in cache) {// si le résultat est en cache
retourner cache [dsid]; // revenez directement à l'objet dans le cache
}
var fsb = new uikit.webctrl.searchbox (dsid); // new
cache [dsid] = fsb; // metter à jour le cache
if (count.length> 100) {// La taille du cache est garantie <= 100
supprimer cache [count.shift ()];
}
Retour FSB;
},
ClearSearchbox: fonction (dsid) {
if (dsid in cache) {
cache [dsid] .clearselection ();
}
}
};
}) ();
CachedSearchbox.AttachSearchbox ("input1");
De cette façon, lorsque nous appelons cachedsearchbox.attachserachbox ("input1") la deuxième fois,
Nous pouvons accéder à l'objet à partir du cache sans créer un nouvel objet SearchBox.
3 Implémentation de l'emballage
Voyons d'abord un exemple sur l'encapsulation. Les variables à l'intérieur ne sont pas accessibles à l'extérieur de la personne, mais sont accessibles en fournissant des fermetures:
La copie de code est la suivante:
var personne = fonction () {
// La portée de la variable est à l'intérieur de la fonction et n'est pas accessible en dehors de la fonction
var name = "Default";
retour {
getName: function () {
nom de retour;
},
setName: function (newname) {
name = newname;
}
}
} ();
imprimer (personne.name); // Accès direct, le résultat n'est pas défini
print (personne.getName ());
personne.setName ("Abruzzi");
print (personne.getName ());
Les résultats sont les suivants:
indéfini
défaut
Abruzzes
4 Un autre objectif important des fermetures est de mettre en œuvre des objets orientés objet. Les langues d'objet traditionnelles fournissent des mécanismes de modèle de classe.
De cette façon, différents objets (instances de classes) ont des membres et des états indépendants et n'interfèrent pas les uns avec les autres. Bien qu'il n'y ait pas de mécanisme tel que la classe en JavaScript, en utilisant des fermetures,
Nous pouvons simuler un tel mécanisme. Parlons de l'exemple ci-dessus:
La copie de code est la suivante:
fonction de fonction () {
var name = "Default";
retour {
getName: function () {
nom de retour;
},
setName: function (newname) {
name = newname;
}
}
};
var John = personne ();
print (John.getName ());
John.Setname ("John");
print (John.getName ());
var jack = personne ();
print (jack.getName ());
jack.setname ("jack");
print (jack.getName ());
Les résultats de l'opération sont les suivants:
défaut
John
défaut
jack
À partir de ce code, nous pouvons voir que John et Jack peuvent être appelés instances de la classe de personne, car l'accès au membre du nom est indépendant et ne s'affiche pas mutuellement.
Ce qui précède est la fonction de la fermeture de JS, qui est très simple et facile à comprendre. J'espère que ce sera utile à mes amis.