关于闭包一些总结

概念：当内部函数被保存到外部时，将会形成闭包。必包会导致原有的作用域链不释放，导致内存泄露。

内存泄露：内存被占用的越多，内存就越来越少，就想泄漏了一样。

function a() {
    function b() {
        var bbb = 234;
        console.log(aaa);
    }
    var aaa = 123;
    return b;
}
var glob = 100;
var demo = a();//demo等于a执行
demo();//执行了b函数


/*
    在a函数return b 后才执行完，销毁aAO. 因为此时没有b(),所以b还是被定义态，和a被执行的状态
    是一. 样的。return b 让a执行时的AO被保存到了外面。因为return b 所以b依然可以访问a的AO。
    所以答案是123。
*/
  

但凡内部函数被保存到外部就一定会生成闭包。（原有的作用域链不释放，在外部也可以访问）

function a () {
    var num = 100;
    function b() {
        num++;
        console.log(num);
    }
    return b;
}

var demo = a();
demo();
demo();

a 被执行 0:a.AO: num = 100
        1: GO: demo = a();
b 被执行 0: bAO:
        1:aAO: num = 100;
        2:GO: demo=a();
每次执行都访问的是被保存在外部的aAO.num。 所以答案是101， 102

 

function a () {
    var aa = 345;
    function b() {
        var bb = 234;
        function c() {
           var cc = 33;
        }
        c();
    }
    b();
}
a();

/*
  a先执行，想要执行完a函数，就需要执行完b函数，想要执行完b函数，就需要执行完c函数。
  哪个先执行完，那个先被销毁。  
*/
a先

必包的作用 

//1.函数累加器，实现共有变量
function add () {
    var count = 0;
    function demo() {
        count++;
        console.log(count)
    }
    return demo;
}
var counter = add();
counter();
counter();
counter();



function test() {
    var num = 100;
    function a() {
        num++;
        console.log(num);
    }
    function b() {
        num--;
        console.log(num);
    }
    return [a, b];
}

var myArr = test();
myArr[0]();//101 用的是test.AO
myArr[1[();//100 用的是myArr[0]执行后的test.AO

//2.可以做缓存，缓存是外部不可见的，但是确实有存储结构
function eater () {
    var food = '';
    var obj = {
        eat: function() {
            console.log("i am eating" + food);
            food = "";
        },
        push: function(myFood) {
            food = myFood;
        }
    }
    return obj;
}

var eater1 = eater();
eater1.push("banana");
eater1.eat();//eater里面的food就是一个隐式的存储结构