闭包

MDN对闭包的定义为

闭包是指那些能够访问自由变量的函数

自由变量？

自由变量是指在函数中使用的，但既不是函数参数也不是函数的局部变量的变量

所以闭包需要由两部分组成

闭包=函数+函数能够访问的自由变量

例：

var a = 1;
function foo(){
    console.log(a)
}

foo();

foo函数访问变量a，但是a既不是函数foo的局部变量，也不是foo函数的参数，所以a就是自由变量，那么函数foo+foo访问的自由变量就构成了闭包吗？

在《JavaScript权威指南》中讲到，从技术的角度讲所有的JavaScript函数都是闭包。

但是在实践角度来说ECMAScript中闭包指：

从理论讲：所有的函数，因为它们都是在创建的时候就讲上层的上下文的数据保存起来了，哪怕是简单的全局变量也是如此，因为函数访问全局变量就相当于在的访问自由变量，是使用了最外层的作用域。
从实践的角度：以下函数才算是闭包
1. 即使创建它的上下文已经销毁，它依然存在（比如，内部函数从父函数中返回）
2. 在代码中引用了自由变量

分析

var scope = "global scope";
function checkscope(){
    var scope = "local scope";

    function f(){
        return scope;
    }

    return f;
}

var foo = checkscope();
foo();

执行过程如下：

进入全局变量，创建全局执行上下文，全局执行上下文压入执行上下文栈。
全局执行上下文初始化
执行checkscope函数，创建checkscope函数执行上下文，checkscope执行上下文被压入执行上下文栈。
checkscope执行上下文初始化，创建变量对象、作用域链、this等。
checkscope函数执行完毕，checkscope执行上下文弹出执行上下文栈。
执行f函数，创建f函数执行上下文，f执行上下文被压入执行上下文栈。
f执行上下文初始化，创建变量对象、作用域链、this等。
f函数执行完毕，f函数上下文从执行上下文栈中弹出。

当f函数执行的时候，checkscope函数上下文已经被销毁（即从执行上下文栈中被弹出），但是却能访问到checkscope中创建的scope属性，主要原因是因为f执行上下中维护了一个作用域链

fContext = {
    Scope:[AO, checkscopeContext.AO, globalContext.VO]
}

就是因为这个作用域链，f函数依然能够读取到checkscopeContext.AO的值，说明了f函数引用了checkscopeContext.AO中的值得时候，即使checkscopeContext被销毁，但是JavaScript依然会让checkscopeContext.AO活在内存中，f函数依然能够通过作用域链找到它，正是因为有这个特性从而实现了闭包。

所以实践总结：

即使创建它的上下文已经销毁，它依然存在与内存中
在代码中引用了自由变量

常见问题

var data = [];
for(var i = 0;i<3;i++>){
    data[i] = function(){
        console.log(i)
    }
}

data[0]();//3
data[1]();//3
data[2]();//3

分析如上代码：
当执行到data[0]()函数之前，此时全局上下文的VO为：

globalContext = {
    VO:{
        data: [...],
        i:3
    }
}

当执行data[0]函数时，data[0]函数的作用域链为：

data[0]Context = {
    Scope: [AO, globalContext.VO]
}

data[0]Context的AO并没有i值，所以会从globalContext.VO中查找，i为3所以打印的结果就是3，data[1]和data[2]是一样的道理。

修改为闭包后代码如下：

var data = [];
for(var i = 0;i<3;i++>){
    data[0] = (function(){
        return function(){
            console.log(i);
        }
    })(i)
}

当函数执行到data[0]函数之前，此时全局上下文的VO为

globalContext = {
    VO:{
        data: [...],
        i:3
    }
}

匿名函数的执行上下文AO为：

匿名函数Context = {
    AO:{
        arguments:{
            0:0,
            length: 1
        },
        i:0
    }
}

data[0]Context的AO中没有i值，所以会沿着作用域链从匿名函数Context.AO中查找，这时候会找到i为0，找到了就不会继续在globalContext.VO中查找。data[1]和data[2]同样的道理。

分析​

常见问题​

分析

常见问题