Ausführliche Erklärung der Schließungen in JavaScript

Schließung: Schließung ist eine Funktion, die auf eine Variable einer anderen Funktion verweist. Da auf die Variable verwiesen wird, wird sie nicht recycelt und kann daher zum Kapseln einer privaten Variablen verwendet werden.

Wenn auf eine innere Funktion außerhalb der Daten verwiesen wird, die ihren Gültigkeitsbereich definieren, wird ein Abschluss der inneren Funktion erstellt. Wenn die innere Funktion beim Aufruf der äußeren Funktion auf eine Variable verweist, die sich in der äußeren Funktion befindet Variablen werden nicht im Speicher freigegeben, da sie für den Abschluss erforderlich sind

Der Bereich der Variablen: Es gibt zwei Arten von Bereichen: globaler Bereich und lokaler Bereich

var n=999;
function f1(){
　　alert(n);
}
f1(); // 999
function f2(){
　　var m=999;
}
alert(m); // error
function f3(){
　　i=999; // 函数内部声明变量的时候，一定要使用 var 声明变量，如果不用 var，此时改变量就变成全局变量
}
f3();
alert(i); // 999

Von außen lesen Holen Sie sich lokal Variablen: Dies ist unter normalen Umständen nicht möglich, Sie können jedoch innerhalb der Funktion eine andere Funktion definieren, sodass die interne Funktion auf die Variablen der externen Funktion zugreifen kann. Darüber hinaus können externe Funktionen nicht auf interne Funktionsvariablen zugreifen. Dies ist die einzigartige „Kettenbereich“-Struktur der JavaScript-Sprache.

function f1() {
  var n = 999;
  function f2() {
    alert(n);
  }
  return f2;
}
var result = f1();
result(); // 999

Abschlüsse können an vielen Stellen verwendet werden. Es hat zwei Hauptverwendungszwecke, wie bereits erwähnt, und die andere besteht darin, die Werte dieser Variablen im Speicher zu behalten Die Variablen in der Funktion werden alle im Speicher gespeichert, was viel Speicher verbraucht, sodass Schließungen nicht missbraucht werden können. Andernfalls kann es zu Leistungsproblemen auf der Webseite und möglicherweise zu Speicherverlusten im IE kommen. Die Lösung besteht darin, alle nicht verwendeten lokalen Variablen zu löschen, bevor die Funktion beendet wird

function f1() {
  var n = 999;
  nAdd = function(){ // nAdd 是全局变量
    n += 1;
  }
  
  function f2() {
    alert(n);
  }
  return f2;
}
var result = f1();
result(); // 999
nAdd();
result(); // 1000

2> Durch den Abschluss wird der Wert der internen Variablen der übergeordneten Funktion außerhalb der übergeordneten Funktion geändert. Wenn Sie daher die übergeordnete Funktion als Objekt, den Abschluss als öffentliche Methode und die internen Variablen als privaten Wert verwenden, müssen Sie vorsichtig sein und dürfen den Wert der Variablen innerhalb der übergeordneten Funktion nicht beiläufig ändern

var name = "The Window";
var object = {
  name : "My Object",
  getNameFunc : function() {
    return function() {
      return this.name;
    };
  },
  getNameFunc2 : function() {
    return () => this.name;
  },
  getNameFunc3 : function() {
    this_ = this;
    return function() {
      return this_.name;
    };
  }
};
alert(object.getNameFunc()());  // The Window，this 指向调用的对象，此处执行的时全局 this 
alert(object.getNameFunc2()()); // My Object，使用箭头函数相当于 getNameFunc3 的写法
alert(object.getNameFunc3()()); // My Object

function outerFun() {
  var a =0;
  alert(a);  
}
var a = 4;
outerFun(); // 0
alert(a); // 4

function outerFun() {
  a = 0; // 没有 var，此时 a 是作用于全局变量，将修改全局变量的 a
  alert(a);  
}
var a=4; // 全局变量 a
outerFun(); // 0
alert(a); // 0

function createFunctions() {
  var result = new Array();
  for (var i=0; i < 10; i++) {
    result[i] = function() {
      return i;
    };
  }
  return result;
}
var funcs = createFunctions();
for (var i=0; i < funcs.length; i++) { // 打印出 10 个 10，在 js 中使用 () 才会执行函数
  console.log(funcs[i]());
}

Das obige ist der detaillierte Inhalt vonAusführliche Erklärung der Schließungen in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!