第5章——作用域闭包

5.1闭包的概念

当函数可以记住并访问所在的词法作用域，就产生了闭包。【有点拗口，暂时记录】
闭包一个最重要的部分就是作用域的查找规则。

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

上面的代码是闭包吗，技术来讲，也许是，单根据闭包的定义来看，这并不是，因为虽然访问了所在的词法作用域，但是没有记住所在的词法作用域。
严格意义上来说就是词法作用域的查找规则。
从纯学术的角度说，在上面的代码片段中，函数 bar() 具有一个涵盖 foo() 作用域的闭包
（事实上，涵盖了它能访问的所有作用域，比如全局作用域）。也可以认为 bar() 被封闭在
了 foo() 的作用域中。为什么呢？原因简单明了，因为 bar() 嵌套在 foo() 内部。
但是通过这种方式定义的闭包并不能直接进行观察，也无法明白在这个代码片段中闭包是
如何工作的。我们可以很容易地理解词法作用域，而闭包则隐藏在代码之后的神秘阴影
里，并不那么容易理解。
下面的代码清晰的展示了闭包

function foo() {
    var a = 2;
    function bar() {
        console.log(a)
    }
    return bar
}
var baz = foo()
baz() //这是闭包的效果

上面的代码中foo返回来了bar这个函数，通过调用foo(),赋值给baz，实际上就是通过不同的标识符引用调用了bar，只不过这样就让bar执行在了自己的自己定义的词法作用域以外，而我们也可以在foo外部的作用域中引用访问 a。
一般来说，引擎的垃圾回收机制用来释放不在使用的内存空间。在上面的代码中，foo()被执行以后，通常会期待foo的整个内部作用域被销毁，但是这里的闭包阻止了这种现象，因为bar（）本身在使用这个作用域。
拜bar（）所声明的位置所赐，它拥有涵盖foo（）内部作用域的闭包，使得该作用域一直存活，以供bar（）在之后任何时间进行引用。
bar（）依然持有对该作用域的引用，这个引用就是闭包
bar()在定义时的词法作用域以外的地方被调用【也就是记住了所在的词法作用域】。闭包使得函数可以访问定义时的词法作用域。
根据闭包的概念，上面的第二个代码就是一个车真正意义上的闭包。
上面提到方式只是闭包的一种，也是最常见的一种。
个人理解：闭包的目的就是使得函数能够在任何地方都能访问定义时所在的词法作用域。以下两种方式也能实现，

function foo() {
    var a = 2
    function baz() {
        console.log() 
    }
    bar(baz)
}
function bar(fn){
    fn() //在这里依然可以访问foo（）
}

var fn
function foo() {
    var a = 2
    function baz(){
        console.log(a)
    }
    fn = baz
}
function bar() {
    fn()//这就是闭包
}
foo()
bar()

无论通过何种手段将内部函数传递到所在词法作用域之外，他都会持有对原始定义的引用，无论在何时执行这个函数，都在使用闭包。
问题

var fn
function foo() {
    var a = 2
    function baz(){
        var b = 2
        console.log(b)
    }
    return baz
}
fn = foo()

有考虑过上面的代码到底有没有用到闭包，但是后来发现，上面这种写法根本没必要，因为foo（）没有存在的意义，在实际情况中我们就会直接定义内部函数baz

3.我懂了什么【不明白】

在定时器，事件监听器，跨窗口通信或者其他任何的异步（或者同步）任务重，只要使用了回调函数，实际上就是在使用闭包。【具体的原理没有弄明白】

4.循环和闭包

for(var i=1;i<6;i++){
	setTimeout(function timer(){
		console.log(i)
	},i*1000)
}

我们对上面代码的预期就是以I1000的间隔，依次输出1,2，3,4，5
但实际并不是这样，是输出5个6，
延迟函数的回调会在循环结束时才执行， 及时延迟时间是0，但是执行次数和循环的次数保持一致，而循环结束时，i为6，所以输出的都是6，但为什么是1秒，而不是i1000
原因解释：

for(var i=1;i<6;i++){
(function () {
	setTimeout(function timer(){
		console.log(i)
	},i*1000)})()
}

上面的代码执行结果和不加立即执行的效果是一样的。虽然采用立即执行函数，可以将每次迭代中延迟函数创建的作用域封闭起来。但是此时的作用域是空的。他需要有自己的变量，用来在每个迭代中储存i的量
iife会声明并立即执行一个函数来创建作用域。但是此时他们的i也是指向要给共同的i，我们需要在每个作用域中创建只属于自己的变量来存储i。

for(var i=1;i<6;i++){
(function () {
	var j = i
	setTimeout(function timer(){
		console.log(j)
	},j*1000)})()
}

上面代码的执行结果

for(var i=1;i<6;i++){
(function (j) {
	setTimeout(function timer(){
		console.log(j)
	},j*1000)})(i)
}

代码可以改成如上样式。
下面的代码可以运行出同样的结果

for(var i=1;i<6;i++){
	let j = i
	setTimeout(function timer(){
		console.log(j)
	},j*1000)
}

for(let i=1;i<6;i++){
	setTimeout(function timer(){
		console.log(i)
	},i*1000)
}

在上面的代码中，我们创建了块作用域，而且利于回调函数使用了闭包，两个联手，天下无敌。

补充

在平时的代码中，我们经常看到for的头部，有时候使用var，有时候使用let，
var: 在循环过程中声明一次，
let：在循环过程中不仅声明一次，每次循环都会声明，随后每个迭代，都会使用上一次迭代结束时的值来初始化这个变量。而且会劫持每个循环。所以说，采用let，就创建了5个独立的作用域。
【为什么上面的例子是闭包】

5.模块

function foo() {
    var something = 'cool'
    var another = [1,2,3]
    function dosomething() {
        console.log(something)
    }
    function doanother() {
        console.log(another.join('!'))
    }
    dosomething()
    doanother()
}
foo()

上面的代码并没有明显的闭包，只不过他们的词法作用域就是foo的内部作用域。
下面的代码是是一个简单的模块。

function foo() {
    var something = 'cool'
    var another = [1,2,3]
    function dosomething() {
        console.log(something)
    }
    function doanother() {
        console.log(another.join('!'))
    }
    return {
        dosomething: dosomething,
        doanother: doanother
    }
}
var foo = foo()
foo.dosomething()
foo.doanother()

上面最终返回的是一个对象，但是实际情况中，我们也可以返回函数，因为函数也是对象，在函数中定义的变量和函数，也可以看成是函数的属性和方法。
在上面的代码中，dosomething和doanother 具有涵盖模块内部作用域的闭包（通过调用coolModule）实现。
如果要更简单的叙述，模块模式需要具备两个条件
1.必须有外部的封闭函数，该函数必须至少被调用一次，（每次调用都会创建一个新的模块实例）
2.封闭函数必须至少返回一个内部函数，这样内部函数才能在私有作用域中形成闭包，并且可以访问或者修改私有状态的属性。

如果只想创建一个模块实例，我们可以采用立即执行函数的模式，进行但离实现。

var foo = (function foo() {
    var something = 'cool'
    var another = [1,2,3]
    function dosomething() {
        console.log(something)
    }
    function doanother() {
        console.log(another.join('!'))
    }
    return {
        dosomething: dosomething,
        doanother: doanother
    }
})()
foo.dosomething()
foo.doanother()

当然，我们也可以给模块提供一个参数。

var foo = (function CoolModule(id){
    function identify1() {
        console.log(id)
    }
    function identify2() {
        console.log( id.toUpperCase());
    }
    function change() {
        publicApi.identify = identify2
    }
    var publicApi = {
        change: change,
        identify: identify1
    }
    return publicApi
})()

通过在模块实例的内部保留对公共API对象的内部引用，可以从内部对模块实例进行修改。

5.1现代的模块机制

看完this以后，回来再看一章节

6.小结

注意：为了不造成内存泄漏，闭包函数调用完毕后，我们要进行 = null 操作

function foo() {
   var a = 0
   function foo1() {
       a += 1
       console.log(a)
   }
   return foo1
}
var baz = foo()
baz()
baz()
baz = null

2.利用闭包定义变量，保护私有变量。

function foo() {
    var name
    this.setName = function(value) {
        name = value
   }
}

var obj = new foo()
obj.setName('mqq')

上面也牵扯到了this的绑定规则——new 绑定
js早期没有类的概念