闭包和垃圾回收机制

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

这段代码有两个特点：

1、函数b嵌套在函数a内部；

2、函数a返回函数b。

这样在执行完var c=a( )后，变量c实际上是指向了函数b，再执行c( )后就会弹出一个窗口显示i的值（第一次为1）。

这段代码其实就创建了一个闭包，这是因为函数a外的变量c引用了函数a内的函数b。

也就是说，当函数a的内部函数b被函数a外的一个变量引用的时候，就创建了一个闭包。

 

    function foo() {
        var a = 1

        function fn() {
            a++;
            console.log(a)

        }
        return fn()
    }
    
    console.log(foo);
    foo();
    foo();

 

    function fn1() {
        var a = 1;
        var b = 2;

        function fn() {
            a++;
            console.log(a)
        }
        return fn;

    }

    var x = fn1();
    x();
    x();
    var x = fn1();
    x();

 通常， 函数的作用域及其所有变量都会在函数执行结束后被销毁。

 但是， 在创建了一个闭包以后， 这个函数的作用域就会一直保存到闭包不存在为止。

    function add(x) {
        return function(y) {
            return x + y
        }
    }
    var add5 = add(5);
    var add10 = add(10);
    console.log(add5(2));
    console.log(add10(2));

相当于在上一次的基础上继续加2，因为上一次结果被存在了内存当中，没有被释放

 

释放对闭包的引用

    add5 = null;

    add10 = null;

从上述代码可以看到add5 和 add10 都是闭包。它们共享相同的函数定义，但是保存了不同的环境。

在 add5 的环境中，x 为 5。而在 add10 中，x 则为 10。最后通过 null 释放了 add5 和 add10 对闭包的引用。

在javascript中， 如果一个对象不再被引用， 那么这个对象就会被垃圾回收机制回收；

如果两个对象互相引用， 而不再被第3者所引用， 那么这两个互相引用的对象也会被回收。

 

    let life = (function() {
        return {
            a: function() {
                console.log('aaaaaa')
            },
            b: function() {
                console.log('bbbbbb')
            },
            c: function() {
                console.log('cccccc')
            }

        }
    })()
    life.a();
    life.b();

 

    let life = {

        a: function() {
            console.log('aaaaaa')
        },
        b: function() {
            console.log('bbbbbb')
        },
        c: function() {
            console.log('cccccc')
        }

    }

    life.a();
    life.b();

【回调和闭包的区别】：

 回调：

    var a;

    function A(callback) {
        var a = 10
        callback(); //---------【注意】：当函数B在这里调用的时候，
        //它并不能访问到a=10这个值，
    }

    function B() {

        if (a === 10) {
            console.log(a)
        } else {
            console.log('thank you')
        }
    }
    A(B);

闭包：

    var a;

    function A() {
        var a = 10

        function B() {     //-----------这里的函数B是闭包，所以可以访问到a=10

            if (a === 10) {
                console.log(a)
            } else {
                console.log('thank you')
            }

        }
        B()
    }
    A();

 

来源：https://www.cnblogs.com/edwardwzw/p/11754101.html