JavaScript 闭包

JavaScript 变量属于本地或全局作用域。全局变量能够通过闭包实现局部(私有)。


全局变量

函数能够访问函数内部定义的所有变量,比如:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p>函数可以访问函数内定义的变量:</p>
  5. <button type="button" onclick="myFunction()">单击这里!</button>
  6. <p id="demo">
  7. <script>
  8. function myFunction() {
  9. var a = 4;
  10. document.getElementById("demo").innerHTML = a * a;
  11. }
  12. </script>
  13. </body>
  14. </html>

但是函数也能访问函数外部定义的变量,比如:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <p>函数可以访问函数外部定义的变量:</p>
  5. <button type="button" onclick="myFunction()">单击这里!</button>
  6. <p id="demo">
  7. <script>
  8. var a = 4;
  9. function myFunction() {
  10. document.getElementById("demo").innerHTML = a * a;
  11. }
  12. </script>
  13. </body>
  14. </html>

在最后这个例子中,a全局变量。

在网页中,全局变量属于 window 对象。

全局变量能够被页面中(以及窗口中)的所有脚本使用和修改。

在第一个例子中,a局部变量。

局部变量只能用于其被定义的函数内部。对于其他函数和脚本代码来说它是不可见的。

拥有相同名称的全局变量和局部变量是不同的变量。修改一个,不会改变其他。

不通过关键词 var 创建的变量总是全局的,即使它们在函数中创建。


变量的生命周期

全局变量生命周期和您的应用程序(窗口、网页)一样久。

局部变量生命周期不长。它们在函数调用时创建,在函数完成后被删除。


一个计数器的困境

假设您想使用变量来计数,并且您希望此计数器可用于所有函数。

您可以使用全局变量和函数来递增计数器:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <h1>JavaScript 函数闭包</h1>
  5. <p>使用全局变量计数。</p>
  6. <p id="demo">
  7. <script>
  8. // 初始化计数器
  9. var counter = 0;
  10. // 递增计数器的函数
  11. function add() {
  12. counter += 1;
  13. }
  14. // 调用三次 add()
  15. add();
  16. add();
  17. add();
  18. // 计数器目前应该是 3
  19. document.getElementById("demo").innerHTML = "计数器是:" + counter;
  20. </script>
  21. </body>
  22. </html>

上述解决方案有一个问题:页面上的任何代码都可以更改计数器,而无需调用 add()。

对于 add() 函数,计数器应该是局部的,以防止其他代码更改它:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <h1>JavaScript 函数闭包</h1>
  5. <p>使用局部变量计数。</p>
  6. <p id="demo">
  7. <script>
  8. // 初始化计数器
  9. var counter = 0;
  10. // 递增计数器的函数
  11. function add() {
  12. var counter = 0;
  13. counter += 1;
  14. }
  15. // 调用三次 add()
  16. add();
  17. add();
  18. add();
  19. // 结果不是 3,因为您混用了全局本地计数器
  20. document.getElementById("demo").innerHTML = "计数器是:" + counter;
  21. </script>
  22. </body>
  23. </html>

它没有用,因为我们显示全局计数器而不是本地计数器。

通过让函数返回它,我们可以删除全局计数器并访问本地计数器:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <h1>JavaScript 闭包</h1>
  5. <p>使用局部变量计数。</p>
  6. <button type="button" onclick="myFunction()">计数!</button>
  7. <p id="demo">0</p>
  8. <script>
  9. // 递增计数器的函数
  10. function add() {
  11. var counter = 0;
  12. counter += 1;
  13. return counter;
  14. }
  15. // 试图递增计数器
  16. function myFunction(){
  17. document.getElementById("demo").innerHTML = add();
  18. }
  19. </script>
  20. </body>
  21. </html>

它没有用,因为我们每次调用函数时都会重置本地计数器。

JavaScript 内部函数可以解决这个问题。


JavaScript 嵌套函数

所有函数都有权访问全局作用域。

事实上,在 JavaScript 中,所有函数都有权访问它们“上面”的作用域。

JavaScript 支持嵌套函数。嵌套函数可以访问其上的作用域。

在本例中,内部函数 plus() 可以访问父函数中的 counter 计数器变量:

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <h1>JavaScript 函数闭包</h1>
  5. <p>使用局部变量计数。</p>
  6. <p id="demo">0</p>
  7. <script>
  8. document.getElementById("demo").innerHTML = add();
  9. function add() {
  10. var counter = 0;
  11. function plus() {counter += 1;}
  12. plus();
  13. return counter;
  14. }
  15. </script>
  16. </body>
  17. </html>

这样即可解决计数器困境,如果我们能够从外面访问 plus() 函数。

我们还需要找到只执行一次 counter = 0 的方法。

我们需要闭包(closure)。


JavaScript 闭包

记得自调用函数吗?这种函数会做什么呢?

  1. <!DOCTYPE html>
  2. <html>
  3. <body>
  4. <h1>JavaScript 闭包</h1>
  5. <p>使用局部变量计数。</p>
  6. <button type="button" onclick="myFunction()">计数!</button>
  7. <p id="demo">0</p>
  8. <script>
  9. var add = (function () {
  10. var counter = 0;
  11. return function () {counter += 1; return counter;}
  12. })();
  13. function myFunction(){
  14. document.getElementById("demo").innerHTML = add();
  15. }
  16. </script>
  17. </body>
  18. </html>
例子解释

变量 add 的赋值是自调用函数的返回值。

这个自调用函数只运行一次。它设置计数器为零(0),并返回函数表达式。

这样 add 成为了函数。最“精彩的”部分是它能够访问父作用域中的计数器。

这被称为 JavaScript 闭包。它使函数拥有“私有”变量成为可能。

计数器被这个匿名函数的作用域保护,并且只能使用 add 函数来修改。

闭包指的是有权访问父作用域的函数,即使在父函数关闭之后。

分类导航