概念

闭包函数

声明在一个函数中的函数，叫做闭包函数。

闭包

内部函数总是可以访问其所在的外部函数中声明的参数和变量，即使在其外部函数被返回（寿命终结）了之后。

特点

让外部访问函数内部变量成为可能；
局部变量会常驻在内存中；
可以避免使用全局变量，防止全局变量污染；
会造成内存泄漏（有一块内存空间被长期占用，而不被释放）

闭包的创建

闭包就是可以创建一个独立的环境，每个闭包里面的环境都是独立的，互不干扰。闭包会发生内存泄漏，每次外部函数执行的时 候，外部函数的引用地址不同，都会重新创建一个新的地址。但凡是当前活动对象中有被内部子集引用的数据，那么这个时候，这个数据不删除，保留一根指针给内部活动对象。

闭包内存泄漏为： key = value，key 被删除了 value 常驻内存中; 局部变量闭包升级版（中间引用的变量） => 自由变量；

闭包的应用场景

结论：闭包找到的是同一地址中父级函数中对应变量最终的值
（最终秘诀就这一句话，每个例子请自行带入这个结论！！！！！！！！！！！！！）

【实例】

【实例1】

  1. function funA(){
  2.   var a = 10;  // funA的活动对象之中;
  3.   return function(){   //匿名函数的活动对象;
  4.         alert(a);
  5.   }
  6. }
  7. var b = funA();
  8. b();  //10

【实例2】

  1. function outerFn(){
  2.   var i = 0; 
  3.   function innerFn(){
  4.       i++;
  5.       console.log(i);
  6.   }
  7.   return innerFn;
  8. }
  9. var inner = outerFn();  //每次外部函数执行的时候,都会开辟一块内存空间,外部函数的地址不同，都会重新创建一个新的地址
  10. inner();
  11. inner();
  12. inner();
  13. var inner2 = outerFn();
  14. inner2();
  15. inner2();
  16. inner2();   //1 2 3 1 2 3

【实例3】

  1. var i = 0;
  2. function outerFn(){
  3.   function innnerFn(){
  4.        i++;
  5.        console.log(i);
  6.   }
  7.   return innnerFn;
  8. }
  9. var inner1 = outerFn();
  10. var inner2 = outerFn();
  11. inner1();
  12. inner2();
  13. inner1();
  14. inner2();     //1 2 3 4

【实例4】

  1. function fn(){
  2.     var a = 3;
  3.     return function(){
  4.         return  ++a;                                     
  5.     }
  6. }
  7. alert(fn()());  //4
  8. alert(fn()());  //4

【实例5】

  1. function outerFn(){
  2. var i = 0;
  3.   function innnerFn(){
  4.       i++;
  5.       console.log(i);
  6.   }
  7.   return innnerFn;
  8. }
  9. var inner1 = outerFn();
  10. var inner2 = outerFn();
  11. inner1();
  12. inner2();
  13. inner1();
  14. inner2();    //1 1 2 2

【实例6】

  1. (function() { 
  2.   var m = 0; 
  3.   function getM() { return m; } 
  4.   function seta(val) { m = val; } 
  5.   window.g = getM; 
  6.   window.f = seta; 
  7. })(); 
  8. f(100);
  9. console.info(g());   //100  闭包找到的是同一地址中父级函数中对应变量最终的值

【实例7】

function a() { 
  var i = 0; 
  function b() { alert(++i); } 
  return b; 
} 
var c = a(); 
c();      //1 
c();      //2

【实例8】

function f() { 
  var count = 0; 
  return  function() { 
      count++; 
      console.info(count); 
  } 
} 
var t1 = f();
t1();     //1 
t1();     //2 
t1();     //3

【实例9】

var add = function(x) { 
  var sum = 1; 
  var tmp = function(x) { 
      sum = sum + x; 
      return tmp;    
  } 
  tmp.toString = function() { 
      return sum; 
  }
  return tmp; 
} 
alert(add(1)(2)(3));     //6

【实例10】

var lis = document.getElementsByTagName("li");
for(var i=0;i<lis.length;i++){
  (function(i){
      lis[i].onclick = function(){
           console.log(i);
      };
  })(i);       //事件处理函数中闭包的写法
}

【实例11】

function m1(){
     var x = 1;
     return function(){
          console.log(++x);
     }
}

m1()();   //2
m1()();   //2
m1()();   //2

var m2 = m1();
m2();   //2
m2();   //3
m2();   //4

【实例12】

var  fn=(function(){
   var  i=10;
   function  fn(){
      console.log(++i);
   }
   return   fn;
})() 
fn();   //11
fn();   //12

【实例13】

function love1(){
     var num = 223;
     var me1 = function() {
           console.log(num);
     }
     num++;
     return me1;
}
var loveme1 = love1();
loveme1();   //输出224

【实例14】

function fun(n,o) {
    console.log(o);
    return {
         fun:function(m) {
               return fun(m,n);
         }
    };
}
var a = fun(0);  //undefined
a.fun(1);  //0  
a.fun(2);  //0  
a.fun(3);  //0  
var b = fun(0).fun(1).fun(2).fun(3);   //undefined  0  1  2
var c = fun(0).fun(1);  
c.fun(2);  
c.fun(3);  //undefined  0  1  1

【实例15】

function fn(){
   var arr = [];
   for(var i = 0;i < 5;i ++){
     arr[i] = function(){
         return i;
     }
   }
   return arr;
}
var list = fn();
for(var i = 0,len = list.length;i < len ; i ++){
   console.log(list[i]());
}  //5 5 5 5 5

【实例16】

function fn(){
  var arr = [];
  for(var i = 0;i < 5;i ++){
    arr[i] = (function(i){
        return function (){
            return i;
        };
    })(i);
  }
  return arr;
}
var list = fn();
for(var i = 0,len = list.length;i < len ; i ++){
  console.log(list[i]());
}  //0 1 2 3 4