Eine einfache Erklärung von Abschlüssen in JS

Jeder hat von Schließungen in JS gehört. Er ist sehr gut und hat einen Referenzwert. Ich hoffe, er kann hilfreich sein.

1. „Der Abschluss besteht darin, bereichsübergreifend auf Variablen zuzugreifen.“

[Beispiel 1]

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

Um den Namen in der getName-Funktion zu erhalten, zuerst im getName Funktion Suchen Sie nach dem Namen im Gültigkeitsbereich, aber er wird nicht gefunden. Dann suchen wir im Gültigkeitsbereich der Benutzerfunktion, aber er wird auch nicht gefunden. Wir verfolgen weiter nach oben und stellen fest, dass der Name im globalen Gültigkeitsbereich vorhanden ist Holen Sie sich den Namenswert und drucken Sie ihn aus. Hier ist es leicht zu verstehen, dass alle 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 derselben fortgesetzt name 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 Gültigkeitsbereich der Benutzerfunktion existiert. Unter normalen Umständen befindet sie sich im externen Gültigkeitsbereich (Hier ist die globale) Auf die Namensvariable kann nicht zugegriffen werden, aber durch Schließen (Rückgabe einer Funktion, die die Variable enthält, hier ist die getName-Funktion) kann bereichsübergreifend auf Variablen zugegriffen werden (externer Zugriff auf 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 in der Umgebung des Großvaters hingerichtet und der Enkel wird in den Vater zurückgebracht. Ursprünglich wurde der Vater hingerichtet, und die Umgebung des Vaters sollte gelöscht werden, aber der Enkel hat auf die Umgebung des Vaters verwiesen, sodass der Vater sie nicht freigeben konnte. Einfach ausgedrückt ist ein Abschluss ein Objekt, das auf die übergeordnete Umgebung verweist und sie an eine übergeordnete Umgebung zurückgibt. „

Wie verstehst du das? 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: Das Ausführen von user() gibt die Funktion getName an zurück Um die Namensvariable abzurufen, müssen Sie die zurückgegebene getName-Funktion einmal ausführen, also ist sie user()()】

Analysieren Sie gemäß Punkt 2 den Code: Die userName-Variable wird im globalen Bereich erstellt (Opa ), speichert den Verweis auf das endgültige Rückgabeergebnis der Benutzerfunktion (dh den Wert des lokalen Variablennamens), führt user()() (Vater) aus und gibt nach der Ausführung unter normalen Umständen den Namen (Enkel) zurück user()() Danach 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 im Bereich des Benutzers existierte), kann die Umgebung des Benutzers nicht freigegeben werden ( wird zu Gedächtnisverlust führen).

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 Umfang ausgeführt, in dem sie definiert sind, nicht in dem Umfang, in dem sie ausgeführt werden.“

Dieser Satz erklärt die Verwendung von Variablen in Zitaten ist hilfreich. 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 den obigen Satz lesen,

Funktionen werden in JavaScript in dem Bereich ausgeführt, in dem sie definiert sind, nicht in dem Bereich, in dem sie ausgeführt werden

执行 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. 外层函数返回内层函数的对象，并且外层函数被调用，结果保存在一个全局的变量中。

相关推荐：

PHP中的闭包和匿名函数分析

深入理解javascript闭包、

详解JavaScript作用域和闭包

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!