Abschlüsse in der funktionalen Javascript-Programmierung verstehen_Javascript-Kenntnisse

Closure ist ein Konzept in der funktionalen Programmierung, das in den 1960er Jahren auftauchte. Die früheste Sprache zur Implementierung von Closing war Scheme, ein Dialekt von LISP. Seitdem wurden Schließungsfunktionen in großem Umfang von anderen Sprachen übernommen.
Die strikte Definition eines Abschlusses ist „eine Menge, die aus einer Funktion (Umgebung) und ihren eingeschlossenen freien Variablen besteht.“ Diese Definition ist für jeden etwas unklar, daher erklären wir sie zunächst anhand von Beispielen und eine weniger strenge Erklärung ist ein Abschluss. und gibt dann Beispiele für einige klassische Verwendungen von Verschlüssen.

Was ist Schließung?

Laienhaft ausgedrückt ist jede Funktion in JavaScript ein Abschluss, aber im Allgemeinen können verschachtelte Funktionen
besser widerspiegeln Um die Eigenschaften des Verschlusses zu zeigen, sehen Sie sich bitte das folgende Beispiel an:

var generateClosure = function() {
var count = 0;
var get = function() {
count ++;
return count;
};
return get;
};
var counter = generateClosure();
console.log(counter()); // 输出 1
console.log(counter()); // 输出 2
console.log(counter()); // 输出 3

In diesem Code gibt es eine lokale Variablenanzahl in der Funktion genericClosure() mit einem Anfangswert von 0. Es gibt auch eine Funktion namens get, die die count-Variable in ihrem übergeordneten Bereich, die Funktion „generateClosure()“, um 1 erhöht und den Wert von count zurückgibt. Der Rückgabewert von genericClosure() ist die Get-Funktion. Extern haben wir die Funktion „generateClosure()“ über die Variable „counter“ aufgerufen und ihren Rückgabewert erhalten, der die Funktion „get“ ist. Dann haben wir mehrmals „counter()“ aufgerufen und festgestellt, dass der zurückgegebene Wert jedes Mal um 1 erhöht wurde.
Schauen wir uns die Merkmale des obigen Beispiels an. Nach dem üblichen Verständnis der imperativen Programmierung ist count eine Variable innerhalb der Funktion „generateClosure“. die Zählvariable Der angewendete Speicherplatz wird freigegeben. Das Problem besteht darin, dass counter() nach Beendigung des Aufrufs von genericClosure() auf die „bereits freigegebene“ Zählvariable verweist und nicht nur kein Fehler auftritt, sondern count auch bei jedem Aufruf von counter() geändert und zurückgegeben wird. Was ist los?
Genau das ist das Merkmal der sogenannten Schließung. Wenn eine Funktion eine darin definierte Funktion zurückgibt, wird ein Abschluss generiert. Der Abschluss umfasst nicht nur die zurückgegebene Funktion, sondern auch die Umgebung, in der die Funktion definiert ist. Wenn im obigen Beispiel die interne Funktion get der Funktion genericClosure() von einer externen Variablen counter referenziert wird, sind die lokalen Variablen von counter und genericClosure() ein Abschluss. Wenn es nicht klar genug ist, kann das folgende Beispiel helfen
Du verstehst:

var generateClosure = function() {
var count = 0;
var get = function() {
count ++;
return count;
};
return get;
};
var counter1 = generateClosure();
var counter2 = generateClosure();
console.log(counter1()); // 输出 1
console.log(counter2()); // 输出 1
console.log(counter1()); // 输出 2
console.log(counter1()); // 输出 3
console.log(counter2()); // 输出 2

Das obige Beispiel erklärt, wie Abschlüsse generiert werden: counter1 und counter2 rufen jeweils die Funktion genericClosure() auf und generieren zwei Instanzen von Abschlüssen. Die Zählvariablen, auf die sie intern verweisen, gehören zu ihren jeweiligen Betriebsumgebungen. Wir können verstehen, dass bei der Rückgabe der Get-Funktion durch genericClosure () die internen Variablen der Funktion „GenerateClosure ()“, auf die get verweisen kann (dh die Zählvariable), auch privat zurückgegeben werden und eine Kopie im Speicher generiert wird then genericClosure( ) Die beiden Instanzen der zurückgegebenen Funktion, counter1 und counter2, sind unabhängig voneinander.

Der Zweck der Schließung

1. Verschachtelte Rückruffunktion
Abschlüsse haben zwei Hauptzwecke: Zum einen werden verschachtelte Rückruffunktionen implementiert, zum anderen werden die Details eines Objekts ausgeblendet. Schauen wir uns zunächst das folgende Codebeispiel an, um verschachtelte Rückruffunktionen zu verstehen. Der folgende Code verwendet MongoDB in Node.js, um eine einfache Funktion zum Hinzufügen von Benutzern zu implementieren:

exports.add_user = function(user_info, callback) {
var uid = parseInt(user_info['uid']);
mongodb.open(function(err, db) {
if (err) {callback(err); return;}
db.collection('users', function(err, collection) {
if (err) {callback(err); return;}
collection.ensureIndex("uid", function(err) {
if (err) {callback(err); return;}
collection.ensureIndex("username", function(err) {
if (err) {callback(err); return;}
collection.findOne({uid: uid}, function(err) {
if (err) {callback(err); return;}
if (doc) {
callback('occupied');
} else {
var user = {
uid: uid,
user: user_info,
};
collection.insert(user, function(err) {
callback(err);
});
}
});
});
});
});
});
};

Wenn Sie mit Node.js oder MongoDB nicht vertraut sind, spielt es keine Rolle. Sie müssen die Details nicht verstehen, sondern nur die allgemeine Logik verstehen. Dieser Code verwendet Verschachtelungsebenen von Abschlüssen, und jede Verschachtelungsebene ist eine Rückruffunktion. Die Rückruffunktion wird nicht sofort ausgeführt, sondern von der angeforderten Funktion zurückgerufen, nachdem die entsprechende Anfrage verarbeitet wurde. Wir können sehen, dass es in jeder Verschachtelungsebene einen Verweis auf den Rückruf gibt und die innerste Ebene auch die von der äußeren Ebene definierte UID-Variable verwendet. Aufgrund des Abschlussmechanismus werden die in ihrem Bereich angewendeten Variablen nicht freigegeben, selbst wenn die äußere Funktion ausgeführt wurde, da die innere Funktion möglicherweise weiterhin auf diese Variablen verweist und so den verschachtelten asynchronen Rückruf perfekt realisiert.

2. Private Mitglieder implementieren
Wir wissen, dass JavaScript-Objekte keine privaten Eigenschaften haben, was bedeutet, dass jede Eigenschaft des Objekts der Außenwelt ausgesetzt ist. Dies kann zu Sicherheitsrisiken führen, wenn beispielsweise der Benutzer des Objekts ein Attribut direkt ändert, wodurch die Konsistenz der internen Daten des Objekts zerstört wird usw. JavaScript verwendet die Konvention, um vor allen privaten Eigenschaften (z. B. _myPrivateProp) einen Unterstrich zu setzen, um anzuzeigen, dass diese Eigenschaft privat ist und externe Objekte sie nicht direkt lesen oder schreiben sollten. Aber dies ist nur eine informelle Vereinbarung, vorausgesetzt, der Benutzer des Objekts tut dies nicht. Gibt es einen strengeren Mechanismus? Die Antwort lautet: Ja, dies kann durch Schließung erreicht werden. Schauen wir uns noch einmal das vorherige Beispiel an:

var generateClosure = function() {
var count = 0;
var get = function() {
count ++;
return count;
};
return get;
};
var counter = generateClosure();
console.log(counter()); // 输出 1
console.log(counter()); // 输出 2
console.log(counter()); // 输出 3

Wir können sehen, dass nur der Aufruf von counter() auf die Zählvariable im Abschluss zugreifen und diese gemäß den Regeln um 1 erhöhen kann. Es ist unmöglich, die Zählvariable auf andere Weise zu finden. Inspiriert durch dieses einfache Beispiel können wir ein Objekt mit einem Abschluss kapseln und nur ein „Accessor“-Objekt zurückgeben, um die Details zu verbergen.

Das Obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, er kann jedem helfen, JavaScript-Schließungen besser zu lernen und zu verstehen.