Detaillierte Erklärung von Javascript-Closures und -Anwendungen

<Skript>
			Funktion Person () {
				var name='Marschall';
				function student(){ //Unterfunktion deklarieren console.log(name);//Verweise auf den Variablennamen im Gültigkeitsbereich der übergeordneten Funktion
				}
			}
			person(); //Funktionsausführung, Abschluss generieren </script>      

	<Skript>
			Funktion Person () {
				var name='marshal'; //Wenn js diese Zeile ausführt, wird ein Abschluss generiert function student(){ //Unterfunktion deklarieren console.log(name); //Variablennamen im Gültigkeitsbereich der übergeordneten Funktion referenzieren
				}
				student(); //Interne Funktion wird in externer Funktion aufgerufen }
			person(); //Funktionsausführung, obwohl die Abschlussbedingung erfüllt ist, wird kein Abschluss generiert </script>

<Skript>
			Funktion Person () {
				var name='Marschall';
				Funktion Student () {
					console.log(name); //Diese Methode enthält Abschlusscode }
				wiederkehrender Student;
			}
			var p = person ();// Da das Unterfunktionsobjekt erstellt wird, wird zu diesem Zeitpunkt der erste Abschluss generiert und der Unterfunktionsstudent wird an p zurückgegeben. Da p nicht verschwindet, wird der von der Unterfunktion referenzierte Variablenname im Speicher gespeichert, bis p = null zurückgesetzt wird p ();// Führe den Abschlusscodeblock der Unterfunktion aus und gib "marhsal" aus.
			p(); //Führe den Closure-Codeblock der Unterfunktion zum zweiten Mal aus und gib „marhsal“ aus.
			person(); //Die zweite Unterfunktion wird erstellt, um das Objekt aufzurufen. Zu diesem Zeitpunkt wird der zweite Abschluss generiert, aber der Codeblock der Unterfunktion „Student“ wird nicht ausgeführt. </script>

<Skript>
			Funktion setTimeoutTest(Nachricht,Zeit){
				setzeTimeout(Funktion(){
					alert(message); //Die verschachtelte untergeordnete Funktion verweist auf die Variable message der übergeordneten Funktion und generiert einen Abschluss }, time);
			}  
			setTimeoutTest('Eingabeaufforderung',1000);
		</Skript>

<Skript>
				Funktion zählen(){
					var i=1;
					Funktion add(){
						ich++;
						konsole.log(i);
					}
					zurückgeben hinzufügen;
				}
				var c=count();//Produktionsabschluss c();//2
				c();//3
				c();//4
		</Skript>

<Skript>
			Funktion zählen(){
				var i=1;
				Funktion add(){
					ich++;
					konsole.log(i);
				}
				zurückgeben hinzufügen;
			}
			var c=Anzahl();
			c();//2
			c(); //3 i's Lebenszyklus wird verlängert </script>

Externer JS-Code out.js implementiert Selbstinkrement und Selbstdekrement (Funktion count(){
	var i=1;
	Funktion add(){
		ich++;
		konsole.log(i);
	}
	Funktion subtrahieren(){
		ich--
		konsole.log(i);
	}
	Fenster.Anzahl={
		hinzufügen: hinzufügen,
		subtrahieren:subtrahieren
	}
})();

Referenzieren Sie den out.js-Code <script src=out.js></script>
		<Skript>
			zählen.add(); //2
			zählen.subtrahieren(); //1
			zählen.subtrahieren(); //0
		</Skript>

<Skript>
     var name="marshal"; //Globale Variablen erstellen var person={
		 Name:"leo",
		 getName:function(){ //Gibt anonyme Funktion zurück return function(){ //Gibt this.name zurück
				return this.name; //Gibt Zeichenfolge zurück }
		 }
	 };
	 alert(person.getName()()); // Ausgabe-Marshal, interne Funktionen können nicht direkt auf die externe Funktion zugreifen.
	 
</Skript>

<Skript>
	     var name="Marschall";
			 var Person = {
				 Name:"leo",
				 getName:Funktion(){
					 var that=this; //Speichere dies in einer anderen Variable, auf die der Abschluss zugreifen kann return function(){
						gib diesen Namen zurück;
					 }
				 }
			 };
			 alert(person.getName()()); //das zeigt auf die Person, nicht auf das Fenster
	</Skript>