Schauen wir uns den Zweck der Schließungen an. Durch die Verwendung von Schließungen können wir viele Dinge tun. Simulieren Sie beispielsweise den objektorientierten Codestil. ausdrücken Code eleganter und präzise; und Verbesserung der Code -Ausführungseffizienz in einigen Aspekten.
1 anonyme Selbstausnahmefunktion
Wir wissen, dass, wenn nicht alle Variablen mit dem Schlüsselwort var hinzugefügt werden, der Standardwert zu den Eigenschaften des globalen Objekts hinzugefügt wird. Das Hinzufügen solcher temporären Variablen zum globalen Objekt gibt es viele Nachteile.
Zum Beispiel: Andere Funktionen können diese Variablen missbrauchen; Das globale Objekt ist zu groß und beeinflusst die Zugangsgeschwindigkeit (da der Wert der Variablen aus der Prototypkette durchquert werden muss).
Neben der Verwendung des VAR -Schlüsselworts jedes Mal, wenn wir die Variable verwenden, stoßen wir häufig auf eine Situation, in der einige Funktionen nur einmal ausgeführt werden müssen und ihre internen Variablen nicht beibehalten werden müssen.
Zum Beispiel können wir bei der Initialisierung der Benutzeroberfläche Verschlüsse verwenden:
Die Codekopie lautet wie folgt:
var datamodel = {
Tisch : [],
Baum : {}
};
(Funktion (dm) {
für (var i = 0; i <dm.table.rows; i ++) {
var row = dm.table.rows [i];
für (var j = 0; j <row.cells; i ++) {
Drawcell (i, j);
}
}
// bauen dm.tree
}) (Datamodel);
Wir erstellen eine anonyme Funktion und führen sie sofort aus, da das externe Variablen nicht in sich verweisen können.
Daher wird es kurz nach der Ausführung veröffentlicht. Der Schlüssel ist, dass dieser Mechanismus das globale Objekt nicht verschmutzen wird.
2 Cache
Nehmen wir ein anderes Beispiel. Stellen Sie sich vor, wir haben ein sehr zeitaufwändiges Funktionsobjekt, das die Verarbeitung jeder Aufruf lange dauert.
Dann müssen wir den berechneten Wert speichern. Beim Aufrufen dieser Funktion suchen wir zuerst im Cache nach. Wenn es nicht gefunden werden kann, werden wir die Berechnung durchführen.
Aktualisieren Sie dann den Cache und geben Sie den Wert zurück. Wenn es gefunden wird, geben Sie einfach den gefundenen Wert direkt zurück. Der Verschluss tut genau dies, da sie keine externen Referenzen freigibt,
Somit kann der Wert innerhalb der Funktion erhalten bleiben.
Die Codekopie lautet wie folgt:
var cachedSearchbox = (function () {
var cache = {},
count = [];
zurückkehren {
Attachsearchbox: Funktion (DSID) {
if (dsid im cache) {// Wenn das Ergebnis im Cache ist
Cache zurückgeben [DSID]; // Kehren Sie direkt zum Objekt im Cache zurück
}
var fsb = new uikit.webctrl.searchbox (dsid); // neu
Cache [DSID] = FSB; // Cache aktualisieren
if (count.length> 100) {// Die Größe des Cache ist garantiert <= 100
Cache löschen [count.shift ()];
}
FSB zurückgeben;
},
ClearSearchbox: Funktion (dsid) {
if (dsid im cache) {
Cache [DSID] .ClearSelection ();
}
}
};
}) ();
CachedSearchbox.attachSearchbox ("input1");
Auf diese Weise, wenn wir CachedSearchbox.attachserachbox ("input1") zum zweiten Mal aufrufen,
Wir können auf das Objekt aus dem Cache zugreifen, ohne ein neues Suchkastenobjekt zu erstellen.
3 Verpackung implementieren
Schauen wir uns zunächst ein Beispiel zur Kapselung an. Die Variablen im Inneren sind außerhalb der Person nicht zugänglich, werden jedoch durch Bereitstellung von Schließungen zugegriffen:
Die Codekopie lautet wie folgt:
var person = function () {
// Der Umfang der Variablen befindet sich innerhalb der Funktion und kann nicht außerhalb der Funktion zugegriffen werden
var name = "Standard";
zurückkehren {
GetName: function () {
Rückgabename;
},
setName: function (newname) {
name = newname;
}
}
} ();
Print (Person.Name); // Direkter Zugriff ist das Ergebnis undefiniert
print (person.getName ());
Person.SetName ("Abruzzi");
print (person.getName ());
Die Ergebnisse sind wie folgt:
undefiniert
Standard
Abruzzi
4 Ein weiterer wichtiger Zweck von Schließungen besteht darin, objektorientierte Objekte zu implementieren. Traditionelle Objektsprachen bieten Klassenvorlagenmechanismen.
Auf diese Weise haben verschiedene Objekte (Klassenanfälle) unabhängige Mitglieder und Staaten und stören sich nicht gegenseitig. Obwohl es keinen solchen Mechanismus wie Klasse in JavaScript gibt, unter Verwendung von Schließungen,
Wir können einen solchen Mechanismus simulieren. Sprechen wir über das obige Beispiel:
Die Codekopie lautet wie folgt:
Funktion person () {
var name = "Standard";
zurückkehren {
GetName: function () {
Rückgabename;
},
setName: function (newname) {
name = newname;
}
}
};
var John = Person ();
print (John.getName ());
John.SetName ("John");
print (John.getName ());
var Jack = Person ();
print (jack.getName ());
Jack.SetName ("Jack");
print (jack.getName ());
Die Betriebsergebnisse sind wie folgt:
Standard
John
Standard
Jack
Aus diesem Code können wir sehen, dass sowohl John als auch Jack als Instanzen der Personklasse bezeichnet werden können, da der Zugriff auf das Namensmitglied unabhängig ist und sich nicht gegenseitig beeinflusst.
Das obige ist die Funktion des JS -Verschlusses, der sehr einfach und leicht zu verstehen ist. Ich hoffe, es wird für meine Freunde hilfreich sein.