作用域和闭包

作用域链

（据我所知）所有的编程语言都存在作用域链。整个代码存在全局作用域、函数作用以及块级作用域。

var a = 1
function foo(){
    var b = 2
    function bar(){
        console.log(a,b)
    }
    bar()
}
foo()

上述代码将会打印1和2。
可以看到上面的代码有三个作用域。全局作用域，foo函数内部的作用域，bar函数内部的作用域，它们的关系如下图。

在函数bar中，可以访问foo作用域和全局作用域的变量,这种作用域的包含关系就被称为作用域链。

词法作用域

一个函数的作用域有两种设计方式

• 词法作用域：根据函数被声明的位置来决定它的作用域
• 动态作用域：根据函数被执行的位置来决定它的作用域

参考下面的代码：

function foo(){
    var a = 3
    function bar(){
        console.log(a)
    }
    return bar
}

function foo1(){
    var a = 4
    var bar1 = foo()
    bar1()
}
foo1()

其实我们可以明显的看到，上述代码实际执行中就是bar函数被执行了。我们也可以看到，bar被定义的时候是在foo函数内部，但是它被执行的时候却是在foo1内部。那么bar中的a到底是3还是4呢？

其实，JS和大多数编程语言一样，也遵守词法作用域的规则。所以上述代码的结果为3。

作用域链和函数调用栈

很多人会把作用域链和函数调用栈弄混淆。
上述代码函数调用栈的变化：

可以看到，在bar函数执行的时候，foo函数已经出栈了。所以有的同学认为foo函数中的局部变量a也就跟着出栈、销毁了。
其实作用链和函数调用栈没有任何联系，这两个概念是独立的系统。JS查找变量的值时候并不是按照函数调用栈来进行查找的，而是通过作用域链，而且查找时符合词法作用域规则。

不同的引擎有不同的方式来实现这一点。比如在V8中，。。。。。

作用域示意图

闭包

上述的现象也就是人们经常说的闭包：根据函数作用域链而不是函数调用栈来查找变量。只要是采取词法作用域规则的函数式编程语言，都必定支持闭包。
这是JS

function foo(){
    var a = 3
    function bar(){
        console.log(a)
    }
    return bar
}

var biu = foo()
biu() // 3

这是python

def foo():
    a = 3
    def bar():
        print(a)
    return bar

biu = foo()
biu() // 3

go

package main

import "fmt"

func foo() func(){
    var a = 3
    return func(){
        fmt.Println(a)
    }
};

func main(){
    var biu = foo()
    biu() // 3
}

可以看到，这些语言都支持闭包。当然，向C++，Java这种不允许将函数作为变量的语言，也就不再闭包的概念了。

闭包的应用

闭包在for -var中的应用

考虑这样的代码

for(var i = 0; i < 2; i++ ) {
    setTimeout(() => {
        console.log(i)
    },10)
}

有的人希望隔10毫秒打印出0、1;但其实上述代码会打印出2、2。
产生这种现象的原因是var声明的变量没有块级作用域，回调函数被执行的时候i的值已经是2了。
要解决上面的问题，可以将var修改为let，或者使用闭包。

for(var i = 0; i < 3; i++) {
    (function(i){
        return setTimeout(()=>{
            console.log(i)
        }, 10)
    })(i)
}

闭包在前端模块化的作用

nodejs 模块化的原理