闭包学习笔记

昨天写的闭包学习笔记，没改标题给误删了，重新搬运
17/05/25，今天研究了下闭包

闭包：内部函数，在外部被引用，就创建了该函数的闭包（通过嵌套在内部的函数实现，通过外部函数将其返回引用）

也就是，如果内部函数引用了外部变量，外部函数调用完毕，这些变量还在内存（不会被回收）

根据经验，很好理解下面这段js代码

function fun(){
    a++; //声明没有用var，相当于全局变量
    console.log(a);
}
var a = 0;
fun(); //a = 1
console.log(a); //a = 1

函数fun()引用了全局变量a，fun()调用完毕，如果a是fun()内部的局部变量，那外部a是不会被设为1的，这是js的作用域链

每次调用fun()，全局变量a都会自增

js的作用域链，也使得外部函数不能访问内部函数的变量，反之却可以

（其实所有function都能称为闭包，不过通常所指是嵌套的内部函数，它更为强大）

理解下面这段代码

function f1(str){ //普通的函数定义
            var n = 1;
            nAdd = function(){ //函数lambda表达式，没有用var，nAdd相当于全局变量
                n += 1;
            }
            function f2(){ //闭包
                console.log(str+"f2 "+n);
            }
            console.log(str+"f1 "+n);
            return f2; //必须通过返回调用闭包
        }
        f1("第一次："); //n = 1
        var result = f1("第二次："); //实际上result指向f2，这里调用了一次f1
        result(); //第一次调用f2,n = 1
        nAdd(); //n+=1
        result(); //第二次调用f2,n = 2

注意，调用f1的时候，并不会调用f2（大概只有愚蠢的我会犯这种错）

n相对f2是一个外部变量，nAdd是一个指向函数的全局变量

f2被外部变量result引用，创建了闭包f2

n和f2()的关系，就好比上一个例子的a和fun()的关系

最后一个例子

 var name = "The Window";
    　　var object = {
    　　　　name : "My Object",
    　　　　getNameFunc1 : function(){
    　　　　　  return this.name;
    　　　　},
           getNameFunc2 : function(){
    　　　　　　return function(){ //
    　　　　　　　　return this.name;
    　　　　　　};
    　　　　},
           getNameFunc3 : function(){
    　　　　　　var m = this;
    　　　　　　return function(){
    　　　　　　　　return m.name;
    　　　　　　};
    　　　　}
    　　};
    　　console.log(object.getNameFunc1()); //My Object
    　　console.log(object.getNameFunc2()()); //The Window
    　　console.log(object.getNameFunc3()()); //My Object
        }

第一个输出好理解

第二个函数fun2()，返回了一个闭包
假如，var f = object.getNameFunc2()();
现在，相当于

f = function(){ 
return this.name; 
} 

直接调用f()，this指向window，也不难理解this.name = The Window

第三个函数fun3()，也是返回了一个闭包，看似和fun2()没有区别
m = this，则m指向了object，m.name相当于object的name = My Object