闭包

定义

• 有权访问另一个函数作用域中的变量的函数

用处

1. 读取外部函数的变量
2. 让变量始终保持在内存中

应用

1. 函数作为返回值
2. 函数作为参数

查找闭包中的变量

• 查找方法：在函数定义的地方（function的地方）向上级作用域查找

// 函数作为返回值
const a = 2;
function out(){
	const a = 1;
	return function(){
		console.log(a);
	}
}
const inner = out();
inner(); // 1

// 函数作为参数
const a = 2;
function out(fn){
	const a = 1;
	fn();
}
function inner(){
	console.log(a);
}
out(inner); // 2

分析

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

var foo = checkscope();
foo();

执行过程：

1. 进入全局代码，创建全局执行上下文，全局执行上下文压入执行上下文栈
2. 全局执行上下文初始化
3. 执行 checkscope 函数，创建 checkscope 函数执行上下文，checkscope 执行上下文被压入执行上下文栈
4. checkscope 执行上下文初始化，创建变量对象、作用域链、this等
5. checkscope 函数执行完毕，checkscope 执行上下文从执行上下文栈中弹出
6. 执行 f 函数，创建 f 函数执行上下文，f 执行上下文被压入执行上下文栈
7. f 执行上下文初始化，创建变量对象、作用域链、this等
8. f 函数执行完毕，f 函数上下文从执行上下文栈中弹出

当 f 函数执行的时候，checkscope 函数上下文已经被销毁了（即从执行上下文栈中被弹出），但是 f 执行上下文维护了一个作用域链

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

即使 checkscopeContext 被销毁了，但是 JavaScript 依然会让 checkscopeContext.AO 活在内存中，f 函数依然可以通过 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

改成闭包解决问题

var data = [];

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

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

当执行 data[0] 函数的时候，data[0] 函数的作用域链发生了改变

data[0]Context = {
    Scope: [AO, 匿名函数Context.AO globalContext.VO]
}

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

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

内存泄漏

在使用计数引用垃圾回收机制的浏览器，闭包容易产生内存泄漏

function assignHandler() {
	const dom = document.getElementById('box')
	dom.onclick = () => console.log(dom.id)
}

如上，匿名函数会一直引用 dom，即 dom 计数至少为 1，则 dom 就会一直保存在闭包中，释放不掉

// 这样改造就不会造成循环引用，而造成内存泄漏了
function assignHandler() {
	const dom = document.getElementById('box')
	const id = dom.id
	dom.onclick = () => console.log(id)
	dom = null
}