Eine einfache Erklärung von Abschlüssen in JS

1. „Abschluss ist der Zugriff auf Variablen über Bereiche hinweg.“

[Beispiel 1]

var name = 'wangxi'
function user () {
 // var name = 'wangxi'
 function getName () {
 console.log(name)
 }
 getName()
}
user() // wangxi

Um den Namen in der Funktion „getName“ zu erhalten, suchen Sie zunächst nach dem Namen im Bereich der Funktion „getName“, aber er wird nicht gefunden. Anschließend wird die Suche im Bereich der Benutzerfunktion fortgesetzt nach oben und stellen Sie fest, dass der Name im globalen Bereich vorhanden ist. Rufen Sie also den Namenswert ab und geben Sie ihn aus. Hier ist es leicht zu verstehen, dass die Variablen im angegebenen Bereich vorhanden sind. Wenn die gewünschte Variable im aktuellen Bereich nicht gefunden werden kann, wird die Suche im übergeordneten Bereich über die Bereichskette bis zur ersten Variable mit demselben Namen fortgesetzt gefunden wird (oder wenn sie nicht gefunden werden kann, wird ein ReferenceError ausgegeben). Dies ist das Konzept der Bereichskette in js, das heißt, der untergeordnete Bereich kann gemäß der Bereichskette auf die Variablen im übergeordneten Bereich zugreifen. Was ist, wenn der übergeordnete Bereich im Gegenteil auf die Variablen im untergeordneten Bereich zugreifen möchte? ——Dies muss durch Schließung erreicht werden.

[Beispiel 2]

function user () {
 var name = 'wangxi'
 return function getName () {
 return name
 }
}
var userName = user()()
console.log(userName) // wangxi

Bei der Analyse des Codes wissen wir, dass es sich bei name um eine lokale Variable handelt, die im Bereich der Benutzerfunktion Under existiert Unter normalen Umständen kann auf die Namensvariable im externen Bereich nicht zugegriffen werden (hier ist der globale), aber durch Schließen (Rückgabe einer Funktion, die die Variable enthält, hier ist die getName-Funktion) kann über Bereiche hinweg auf die Variable zugegriffen werden (externer Zugriff intern). ). Daher sollte die obige Anweisung vollständig wie folgt verstanden werden:

Bei Abschluss handelt es sich um den bereichsübergreifenden Zugriff auf Variablen – der innere Bereich kann einen Verweis auf die Variablen im äußeren Bereich aufrechterhalten, sodass (mehr) der äußere Bereich auf Variablen zugreifen kann im inneren Bereich. (Wenn Sie es immer noch nicht verstehen, lesen Sie die nächste Analyse)

2. „Abschluss: Papa wird im Umfeld von Opa hingerichtet, und der Enkel auch Ursprünglich sollte die Umgebung des Vaters nach der Hinrichtung des Vaters gelöscht werden, aber der Enkel verweist auf die Umgebung des Vaters, sodass der Vater sie nicht freigeben kann. Einfach ausgedrückt ist ein Abschluss ein Objekt, das auf die Umgebung des Vaters verweist dort. Ein Objekt wurde von der übergeordneten Umgebung in eine übergeordnete Umgebung zurückgegeben. „

Wie ist das zu verstehen? Schauen Sie sich zunächst den folgenden Code an:

[Beispiel 3]

function user () {
 var name = 'wangxi'
 return name
}
var userName = user()
console.log(userName) // wangxi

F: Handelt es sich um einen Abschluss?

A: Natürlich nicht. Zunächst müssen Sie verstehen, was ein Abschluss ist. Obwohl es den Anschein hat, dass auf den lokalen Variablennamen in der Benutzerfunktion im globalen Bereich zugegriffen wird, besteht das Problem darin, dass nach der Ausführung des Benutzers auch der Name zerstört wird, dh der Lebenszyklus der lokalen Variablen in der Funktion existiert nur während Im Deklarationszyklus der Funktion wird die Funktion zerstört und die Variablen innerhalb der Funktion werden automatisch zerstört.

Aber die Verwendung von Abschlüssen ist das Gegenteil. Nachdem die Funktion ausgeführt wurde, endet der Lebenszyklus, aber die Variablen im äußeren Bereich, auf den der Abschluss verweist, sind immer noch vorhanden, bis der Bereich, der den Abschluss ausführt, vorhanden ist Zerstören, die lokalen Variablen hier werden zerstört (wenn der Abschluss in der globalen Umgebung referenziert wird, wird der durch den Abschluss referenzierte Bereich nur zerstört, wenn die globale Umgebung zerstört wird, z. B. wenn das Programm beendet wird, der Browser geschlossen wird usw. ). Um Speicherverluste durch Verschlüsse zu vermeiden, wird daher empfohlen, Verschlüsse nach der Verwendung manuell zu zerstören. Immer noch das Gleiche wie Beispiel 2 oben, leicht modifiziert:

[Beispiel 4]

function user () {
 var name = 'wangxi'
 return function getName () {
 return name
 }
}
var userName = user()() // userName 变量中始终保持着对 name 的引用
console.log(userName) // wangxi
userName = null // 销毁闭包，释放内存

[Warum user()() zwei Klammern hat: Durch Ausführen von user() wird die Funktion getName zurückgegeben. Um die Namensvariable zu erhalten, müssen Sie die zurückgegebene Funktion getName einmal ausführen, also ist sie user()()】

Analysieren Sie den Code gemäß Punkt 2: in Die globale Variable userName (Großvater) wird im Gültigkeitsbereich erstellt und der Verweis auf das endgültige Rückgabeergebnis der Benutzerfunktion gespeichert (dh der Wert des lokalen Variablennamens User()() (Vater). ausgeführt und der Name (Enkel) wird zurückgegeben. Nach der Ausführung von user()() sollte die Umgebung des Benutzers (Vater) gelöscht werden, da sich der zurückgegebene Ergebnisname (Enkel) jedoch auf die Umgebung des Vaters bezieht (da der Name ursprünglich in existierte). der Umfang des Benutzers), Infolgedessen kann die Umgebung des Benutzers nicht freigegeben werden (was zu Speicherverlust führt).

Also [„Ein Abschluss ist ein Objekt, das auf die übergeordnete Umgebung verweist und ein Objekt von der übergeordneten Umgebung an eine Umgebung auf höherer Ebene zurückgibt.“] Wie ist das zu verstehen?

Anders ausgedrückt: Wenn eine Funktion auf ein Objekt in der übergeordneten Umgebung verweist und das Objekt in dieser Funktion an die übergeordnete Umgebung zurückgibt, dann ist diese Funktion ein Abschluss.

Sehen Sie sich das obige Beispiel an:

Die Funktion getName verweist auf das Objekt (Variablenname) in der Benutzerumgebung (übergeordnet) und gibt die Namensvariable an die globale Umgebung (höhere Ebene) zurück. in der Funktionsumgebung), daher ist getName ein Abschluss.

3. „Funktionen in JavaScript werden in dem Bereich ausgeführt, in dem sie definiert sind, nicht in dem Bereich, in dem sie ausgeführt werden.“

Dieser Satz ist sehr hilfreich, um den Verweis auf Variablen in Abschlüssen zu verstehen. Schauen wir uns das folgende Beispiel an:

var name = 'Schopenhauer'
function getName () {
 console.log(name)
}
function myName () {
 var name = 'wangxi'
 getName()
}
myName() // Schopenhauer

Wenn das Ausgabeergebnis der Ausführung von myName() anders ist als das, was Sie sich vorgestellt haben, müssen Sie zurückgehen und sich das ansehen oben. Das ist es,

JavaScript 中的函数运行在它们被定义的作用域里，而不是它们被执行的作用域里

执行 myName，函数内部执行了 getName，而 getName 是在全局环境下定义的，因此尽管在 myName 中定义了变量 name，对getName 的执行并无影响，getName 中打印的依然是全局作用域下的 name。

我们稍微改一下代码:

var name = 'Schopenhauer'
function getName () {
　 var name = 'Aristotle'
 var intro = function() { // 这是一个闭包
  console.log('I am ' + name)
 }
 return intro
}
function showMyName () {
 var name = 'wangxi'
 var myName = getName()
 myName()
}
showMyName() // I am Aristotle

结果和你想象的一样吗？结果留作聪明的你自己分析~

以上就是对 js 中闭包的理解，如果有误，欢迎指正。最后引用一段知乎问题下关于闭包概念的一个回答。

什么是闭包?

简单来说，闭包是指可以访问另一个函数作用域变量的函数，一般是定义在外层函数中的内层函数。

为什么需要闭包？

局部变量无法共享和长久的保存，而全局变量可能造成变量污染，所以我们希望有一种机制既可以长久的保存变量又不会造成全局污染。

特点

• 占用更多内存

• 不容易被释放

何时使用？

变量既想反复使用，又想避免全局污染

如何使用？

1. 定义外层函数，封装被保护的局部变量。

2. 定义内层函数，执行对外部函数变量的操作。

3. 外层函数返回内层函数的对象，并且外层函数被调用，结果保存在一个全局的变量中。

Das obige ist der detaillierte Inhalt vonEine einfache Erklärung von Abschlüssen in JS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!