闭包的理解

什么是闭包

闭包是一种特殊的对象,能够读取其他函数内部变量的函数。在javascript中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。

通俗点就是:外部函数调用之后，其变量对象本应该被销毁，但闭包的存在使我们仍然可以访问外部函数的变量对象

function test(){
	var a = 1; // 定义一个内部变量
	return function(){
		return a; // 返回a变量值
	}
}
var b = test();
console.log(b()) // 1

产生一个闭包

创建闭包最常见方式，就是在一个函数内部创建另一个函数。下面例子 test中的fn就是一个闭包：

function test(){
	var a = 1,b=2;
	function fn(){
		return a+b; // 返回a+b变量值
	}	
    return fn
}

闭包的作用域链包含着它自己的作用域，以及包含它的函数的作用域和全局作用域。

闭包的注意事项

.通常，函数的作用域及其所有变量都会在函数执行结束后被销毁。但是，在创建了一个闭包以后，这个函数的作用域就会一直保存到闭包不存在为止。

function test(age){	
    return function(name){
        return `${name}:${age}岁`;
    }
	
}
var age10 = test(10);
var age20 = test(20);

console.log(age10('张三')); // 张三:10
console.log(age20('李四')); // 李四20岁

//释放对闭包的引用
age10 = null;
age20 = null;

从上述代码可以看到age10和 age20都是闭包。它们共享相同的函数定义，但是保存了不同的环境。在 age10的环境中，age为 10。而在 age20 中，age 则为 20。最后通过 null 释放了 age10和 age20对闭包的引用。

在javascript中，如果一个对象不再被引用，那么这个对象就会被垃圾回收机制回收,
如果两个对象互相引用，而不再被第3者所引用，那么这两个互相引用的对象也会被回收。

闭包只能取得包含函数中的任何变量的最后一个值

function outer() {
      var result = [];
      for (var i= 0;i<10; i++){
        result[i]=function () {
            console.info(i)
        }
     }
     return result;
}
// 当outer执行完毕后，其作用域被销毁，但它的变量对象仍保存在内存中，得以被匿名访问，这时i的值为10。
outer()[0](); // 10
outer()[2](); // 10

/*要想保存在循环过程中每一个i的值，需要在匿名函数外部再套用一个匿名函数，
在这个匿名函数中定义另一个变量并且立即执行来保存i的值。*/
function outer() {
      var result = [];
      for(var i = 0; i<10; i++){
        result[i] = function (num) {
             return function() {
                // 此时访问的num，是上层函数执行环境的num，数组有10个函数对象，每个对象的执行环境下的number都不一样
                console.info(num);    
             }
        }(i)
     }
     return result
}
// 这时最内部的匿名函数访问的是num的值，所以数组中10个匿名函数的返回值就是1-10。
outer()[0](); // 0
outer()[2](); // 2

闭包中的this对象

var name = 'window';
var obj = {
    name:'object',
    getName:function(){
        return function(){
            return this.name;
        }
    }
};
console.log(obj.getName()) // window
// 在上面这段代码中，obj.getName()()实际上是在全局作用域中调用了匿名函数，this指向了window。

如果想使this指向外部函数的执行环境，可以这样改写：

var name3 = 'window';
var obj3 = {
    name:'object',
    getName:function(){
        var that = this;
        return function(){
            return that.name;
        }
    }
};
console.log(obj.getName()) // "object"

在闭包中，arguments与this也有相同的问题。下面的情况也要注意：

var name = 'window';
var obj = {
name:'object',
    getName:function(){
        return this.name;
    }
};

obj.getName() // "object"
(obj.getName = obj.getName)(); // "window"

/*obj.getName();这时getName()是在对象obj的环境中执行的，所以this指向obj。
(obj.getName = obj.getName)赋值语句返回的是等号右边的值，在全局作用域中返回，
所以(obj.getName = obj.getName)();的this指向全局。要把函数名和函数功能分割开来。
*/

内存泄漏:

闭包会引用包含函数的整个变量对象，如果闭包的作用域链中保存着一个HTML元素，那么就意味着该元素无法被销毁。所以我们有必要在对这个元素操作完之后主动销毁。

function  showId() {
    var el = document.getElementById("app")
    el.onclick = function(){
      aler(el.id)   // 这样会导致闭包引用外层的el，当执行完showId后，el无法释放
    }
}

// 改成下面
function  showId() {
    var el = document.getElementById("app")
    var id  = el.id
    el.onclick = function(){
      aler(id)   // 这样会导致闭包引用外层的el，当执行完showId后，el无法释放
    }
    el = null    // 主动释放el
}

函数内部的定时器

当函数内部的定时器引用了外部函数的变量对象时，该变量对象不会被销毁。

(function(){
	var i = 0;
	setInterval(function(){
		console.log(i++)
	},1000)
})()

闭包的应用

应用闭包的主要场合是：设计私有的方法和变量。
任何在函数中定义的变量，都可以认为是私有变量，因为不能在函数外部访问这些变量。私有变量包括函数的参数、局部变量和函数内定义的其他函数。
把有权访问私有变量的公有方法称为特权方法（privileged method）。
 

function Animal(){
    // 私有变量
    var dog = '狗狗';
    function go(){console.log('go!!!')}
    // 特权方法
    this.getDog = function(){
        return dog;
    }
}
var a = new Animal();
a.getDog(); // 狗狗

/*在这里，我们需要理解两个概念：
模块模式（The Module Pattern）：为单例创建私有变量和方法。
单例（singleton）：指的是只有一个实例的对象。JavaScript 一般以对象字面量的方式来创建一个单例对象。
*/

普通模式创建的单例:

var obj = {
	name:'dog',
	eat:function(){
		console.log('粑粑')
	},
	getName:function (){
		return this.name
	}
}

模块模式创建单例:

var obj = (function(){
    // 私有变量
    var weight = 100;
    var eat = function (){
        console.log('粑粑');
    }
    //特权(或者公有),属性和方法
    return {
        name:'dog',
        getWeight:function(){
            return weight;
        }
    }
})() 

匿名函数最大的用途是创建闭包，并且还可以构建命名空间，以减少全局变量的使用。从而使用闭包模块化代码，减少全局变量的污染。

var objEvent = objEvent || {};
(function(){
    var addFn = function(){}
    var removeFn = function(){}

    objEvent.addEvent = addFn;
    objEvent.removeEvent = removeFn ;
})()

/*
在这段代码中函数 addEvent 和 removeEvent 都是局部变量，但我们可以通过全局变量 objEvent 使用它，
这就大大减少了全局变量的使用，增强了网页的安全性。
*/

闭包的使用技巧

1.用闭包解决递归调用问题

function  factorial(num) {
   if(num<= 1) {
       return 1;
   } else {
      return num * factorial(num-1)
   }
}
var anotherFactorial = factorial
factorial = null
anotherFactorial(4)   // 报错 ，因为最好是return num* arguments.callee（num-1），arguments.callee指向当前执行函数，但是在严格模式下不能使用该属性也会报错，所以借助闭包来实现


// 使用闭包实现递归
function newFactorial = （function f(num){
    if(num<1) {return 1}
    else {
       return num* f(num-1)
    }
}） //这样就没有问题了，实际上起作用的是闭包函数f，而不是外面的函数newFactorial

2.用闭包模仿块级作用域**,(es6没出来之前，用var定义变量存在变量提升问题，eg:)

for(var i=0; i<10; i++){
    console.info(i)
}
alert(i)  // 变量提升，弹出10

//为了避免i的提升可以这样做
(function () {
    for(var i=0; i<10; i++){
         console.info(i)
    }
})()
alert(i)   // underfined   因为i随着闭包函数的退出，执行环境销毁，变量回收,当然现在大多用es6的let 和const 定义。

 

常用小案例(js使用闭包点击li获取他的索引值):

/*通过闭包获取当前点击的索引*/
<ul>
    <li class="sll-li">aaa</li>
    <li class="sll-li">bbb</li>
    <li class="sll-li">ccc</li>
    <li class="sll-li">ddd</li>
    <li class="sll-li">eee</li>
</ul>

var $o = document.getElementsByClassName('sll-li');
for (var i=0;i<$o.length-1;i++){
	$o[i].onclick=function(){
		console.log(i);// 不管点击哪个li都是4
	}
}

var $o = document.getElementsByClassName('sll-li');
for (var i=0;i<$o.length-1;i++){
	$o[i].onclick=function(num){
  		return function(){
			console.log(num);// 点击第几个就是第几个i
		}
	}(i)
}