作用

1. 使用函数内部的变量在函数执行完后, 仍然存活在内存中(延长了局部变量的生命周期)
2. 让函数外部可以操作(读写)到函数内部的数据(变量/函数)
问题:
  1. 函数执行完后, 函数内部声明的局部变量一般是不存在, 存在于闭包中的变量才可能存在
  2. 在函数外部不能直接访问函数内部的局部变量, 但可以通过闭包让外部操作它

产生方式

1.当一个嵌套的内部函数引用了嵌套的外部函数的变量(函数)时, 就产生了闭包
闭包是什么:
  1.使用chrome调试查看时 可以当做一个包含被引用变量的对象

声明周期

1. 产生: 在嵌套内部函数定义执行完时就产生了(不是在调用)
2. 死亡: 在嵌套的内部函数成为垃圾对象时
function fn1() {
    //此时闭包就已经产生了(函数提升, 内部函数对象已经创建了)
    var a = 2
    function fn2 () {
      a++
      console.log(a)
    }
    return fn2
  }
  var f = fn1()
  f() // 3
  f() // 4
  f = null //闭包死亡(包含闭包的函数对象成为垃圾对象)

缺点

1. 缺点
  * 函数执行完后, 函数内的局部变量没有释放, 占用内存时间会变长
  * 容易造成内存泄露
2. 解决
  * 能不用闭包就不用
  * 及时释放
  function fn1() {
    var arr = new Array[100000]
    function fn2() {
      console.log(arr.length)
    }
    return fn2
  }
  var f = fn1()
  f()

  f = null //让内部函数成为垃圾对象-->回收闭包

对象的形式操作 ,这里体现了面向对象的封装, private,向外暴露接口,只能通过对象的方法去操作变量

function A(){
            var num=0;
            function add(){
                num++;
            }
            function jj(){
                num--;
            }
            function rst(){
                console.log(num);
            }
            this.add = function(){
                return add; 
            }
            this.jj = function(){
                return jj; 
            }
            this.rst = function(){
                return rst; 
            }
        }
        var a = new A();
        a.add()();//1
        a.add()();//2
        a.add()();//3
        a.add()();//4
        a.add()();//5
        a.rst()();//5
        a.jj()();//4
        a.rst()();//4