Detaillierte Erklärung des Abschlusses in Javascript_Javascript-Kenntnissen

In JavaScript kann eine Funktion als eine Art Daten betrachtet werden, die einer Variablen zugewiesen und in einer anderen Funktion verschachtelt werden kann.

var fun = function(){
  console.log("平底斜");
}

function fun(){
  var n=10;
  function son(){
    n++;
  }
  son();
  console.log(n);
}
fun(); //11
fun(); //11

Lassen Sie uns den zweiten Codeabschnitt oben leicht modifizieren:

var n=10;
function fun(){
  function son(){
    n++;
  }
  son();
  console.log(n);
}
fun(); //11
fun(); //12

Erkennen Sie den Unterschied? Wenn Sie die Ergebnisse der Codeausführung nicht verstehen, lesen Sie bitte den vorherigen Blogbeitrag für eine Erklärung des JavaScript-Bereichs und der Bereichskette.

Die Variable n im obigen Code ist eine globale Variable und kann jederzeit neu zugewiesen werden, ohne die Fun-Funktion aufzurufen. Um zu verhindern, dass die Variable n verschmutzt wird, oder um die Verschmutzung globaler Variablen zu verringern, müssen wir n als lokale Variable in die Funktion einfügen.

function fun(){
  var n=10;
  function son(){
    n++;
    console.log(n);
  }
  son();
}
fun(); //11
fun(); //11

Wenn wir die Sohnfunktion global direkt aufrufen können, können wir den gewünschten Effekt erzielen. Die Sohnfunktion existiert nun als lokale Variable. Um global darauf zuzugreifen, gibt es im Allgemeinen zwei Methoden:

Eine besteht darin, globalen Variablen Werte zuzuweisen

var a;
function fun(){
  var n=10;
  a = function son(){
    n++;
    console.log(n);
  }
}
fun(); //son()
a(); //11
a(); //12

Die andere besteht darin, Return zu verwenden, um den Wert zurückzugeben

function fun(){
  var n=10;
  return function son(){
    n++;
    console.log(n);
  }
}
var a=fun();
a(); //11
a(); //12

Die Funktion son() oben ist ein Abschluss. In gewissem Sinne können alle Funktionen als Abschlüsse betrachtet werden. Ein Abschluss ist eine Funktion, die auf Variablen im Bereich der äußeren Funktion zugreifen kann.

var a;
function fun(){
  var n=10;
  a = function son(){
    n++;
    console.log(n);
  }
  return a();
}
fun(); //11
a(); //12
a(); //13
fun(); //11
a(); //12
a(); //13

Es ist immer noch der obige Code. Lassen Sie uns ihn leicht modifizieren und uns die Ausführungsergebnisse ansehen. Dies liegt daran, dass die Variable n jedes Mal initialisiert wird, wenn die Funktion fun() ausgeführt wird.

Der Vorteil der Schließung besteht darin, globale Variablen zu reduzieren, globale Verschmutzung zu vermeiden und lokale Variablen im Speicher zu speichern. Dies ist jedoch sowohl ein Vorteil als auch ein Nachteil. Wenn ein Codeabschnitt zu viele Schließungen enthält, kann dies zu Speicherverlusten führen. Da die lokalen Variablen im Abschluss nicht vom Garbage-Collection-Mechanismus recycelt werden, müssen sie manuell null zugewiesen werden (zu Speicherlecks wird später ein separates Thema geöffnet)