JS -Schließung
Was vor dem Schließen zu wissen zu wissen
1. Funktionsumfang
(1). Die spezielle Merkmale der JS -Sprache ist, dass globale Variablen direkt in Funktionen gelesen werden können
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
var n = 100;
Funktion Eltern () {
Alarm (n);
}
Eltern (); // 100
</script>
Wenn in PHP
Die Codekopie lautet wie folgt:
<? Php
$ n = 100;
Funktion Eltern () {
echo $ n;
}
Eltern (); // Der Fehler wird gemeldet. N ist nicht definiert
?>
(2). Lokale Variablen innerhalb der Funktion können nicht außerhalb der Funktion gelesen werden
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktion Eltern () {
var m = 50;
}
Elternteil();
Alarm (m); // Der Fehler m ist nicht definiert
</script>
Beachten Sie, dass Sie bei interner Deklarierung von Variablen VAR hinzufügen müssen, da sonst eine globale Variable deklariert wird.
Die Codekopie lautet wie folgt:
Funktion Eltern () {
M = 50;
}
Elternteil();
Alarm (m); // 50
// Natürlich ist das in PHP noch mehr.
Die Codekopie lautet wie folgt:
<? Php
Funktion Eltern () {
Global $ m; // Global, Definition und Zuordnung sollten getrennt werden
$ m = 50;
}
Elternteil();
echo $ m; // 50
?>
// Wenn es keine globale gibt, gibt es keine Definitionsfehler
Manchmal müssen Sie die Eigenschaften des Umfangs der JS -Variablen verwenden, wenn Sie lokale Variablen in der Funktion erhalten müssen. Das Definieren von untergeordneten Funktionen in der Funktion für untergeordnete Funktionen ist beispielsweise die übergeordnete Funktion ihre globale und die untergeordnete Funktion kann auf die Variablen in der übergeordneten Funktion zugreifen (für den gesamten JS -Code ist es eine lokale Variable)
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktion Eltern () {
var m = 50;
Funktion Son () {
Alarm (m);
}
Rückkehr Sohn;
}
var s = parent (); // das Ergebnis global speichern
s (); // 50
</script>
Alle lokalen Variablen innerhalb von Eltern sind für ihre Kinderfunktionen sichtbar, aber lokale Variablen in ihren Kinderfunktionen sind für ihre übergeordneten Funktionen unsichtbar. Dies ist die in JS einzigartige Kettenbereichstruktur. Das untergeordnete Objekt sucht alle übergeordneten Objekte von Variablen nach Ebene. Alle Variablen des übergeordneten Objekts sind für die untergeordneten Objekte sichtbar, ansonsten gilt es nicht! Die obige Sohnfunktion ist eine Schließung
Einige Schüler können dies tun
Die Codekopie lautet wie folgt:
Funktion Eltern () {
var m = 50;
Funktion Son () {
Alarm (m);
}
}
Elternteil();
Son () // Der Funktionssohn ist nicht definiert
Beachten Sie, dass in JavaScript die in der Funktion deklarierten Funktionen lokal sind und nach Ausführung der Funktion freigegeben werden.
Achten Sie auf den Unterschied zwischen diesem und PHP
Die Codekopie lautet wie folgt:
<? Php
Funktion Eltern () {
Funktion Son () {
$ m = 50;
echo $ m;
}
}
Elternteil();
Son (); // Ausgabe 50 meldet keinen Fehler
?>
Schließung
Funktionen definieren interne Funktionen, Brücken, die interne und externe Funktionen verbinden
Es gibt 2 Funktionen von Schließungen:
Erstens die Lesefunktion in den oben genannten Variablen,
Die zweite besteht darin, die Werte dieser Variablen im Speicher zu speichern, um die Datenfreigabe zu realisieren
Hier sind einige Beispiele für Schließungen
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
var cnt = (function () {
var i = 0;
return function () {
Alarm (i);
i ++;
}
}) ();
cnt (); // 0
cnt (); // 1
cnt (); // 2
cnt (); // 3
</script>
Ich speichere das Ausführungsergebnis der anonymen Funktion (dh die Erklärung der Unterfunktion der globalen Variablenkürzung) im Speicher
Bei der Ausführung von cut () wird der Wert direkt aus dem Speicher abgerufen. Nur die CNT () -Funktion kann aufgerufen werden, und es ist nicht möglich, direkt zu alarmieren (i).
Sie können auch Parameter auf die Schließung übertragen
Die Codekopie lautet wie folgt:
var cnt = (Funktion (num) {
return function () {
Alarm (num);
num ++;
}
}) (5);
cnt (); // 5
cnt (); // 6
cnt (); // 7
// Natürlich können Sie beim Aufrufen auch Parameter übergeben
var cnt = (function () {
var i = 0;
Rückgabefunktion (num) {
num+= i;
Alarm (num);
i ++;
}
}) ();
cnt (1); // 1
cnt (2); // 3
cnt (3); // 5
Um ein besseres Verständnis für Schließungen zu haben, betrachten wir den folgenden Code
Zum Beispiel möchte ich ein Array mit 5 Funktionen im Array zurückgeben, die erste Funktion taucht 0 auf und die zweite taucht 1 auf 1 ...
Wenn der Code so geschrieben ist
Die Codekopie lautet wie folgt:
Funktionsbox () {
var arr = [];
für (i = 0; i <5; i ++) {
arr = function () {return i;}
}
arr zurückgeben;
}
var a = box ();
Alarm (a); // Array mit fünf Funktionskörpern
Alarm (a [0] ());
Alarm (a [1] ());
Der Popup-Funktionskörper
function () {return i;}}
Schließlich ist dies 4 und dann wird ++ 5
Für Schleifenstopps
Es wurde festgestellt, dass alle 5 aufgetaucht sind, was offensichtlich nicht unseren Anforderungen entsprach
Lösung 1
Selbstausführung von Funktionen im Inneren
Die Codekopie lautet wie folgt:
Funktionsbox () {
var arr = [];
für (i = 0; i <5; i ++) {
arr = (Funktion (num) {return i;}) (i);
}
arr zurückgeben;
}
var a = box ();
für (var i = 0; i <A.Length; i ++) {
Alarm (a);
}
Wir haben jedoch festgestellt, dass die Elemente im zurückgegebenen Array das Ergebnis der Funktionsausführung sind, aber wir wollen, dass die Funktion aktualisiert werden muss.
Lösung 2
Schließung Implementierung
Die Codekopie lautet wie folgt:
Funktionsbox () {
var arr = [];
für (var i = 0; i <5; i ++) {
arr = (Funktion (num) {
return function () {return num;}
})(ich);
}
arr zurückgeben;
}
var arr = box ();
für (var i = 0; i <5; i ++) {
Alarm (arr ()); // 0,1,2,3,4
}
Schlüsselcode
Die Codekopie lautet wie folgt:
arr = (Funktion (num) {
return function () {return num;}
})(ich);
Wenn i = 0
arr [0] = (Funktion (num) {return function () {return num;}}) (0);
1 Uhr
arr [1] = (Funktion (num) {return function () {return num;}}) (1);
Die oben genannten sind die Vorteile von Schließungen! Sehr einfach und praktisch.