闭包--闭包作用之保存(一)

闭包作用解析：保存

1. 函数执行形成一个私有作用域，函数执行完成，开成的这个栈内存一般情况下都会自动释放
2. 函数执行完成，当前私有作用哉(栈内存)中的某一部分内容被内存以外的其它东西(变量/元素的事件)占用了，当前的栈内存就不能释放掉，也就形成了不销毁的私有作用域(里面的私有变量也不会销毁)

函数作用域

1. 函数内部可以访问函数外部的变量，
2. 函数外部不可以访问函数内部的变量
3. 当在函数外部定义一个变量，变量在函数内部发生了变化，函数内部和外部都能访问到这个变量

        var a = 1;
        function fn1(){
            a++;
            console.log(a)  //2
        }
        fn1()
        console.log(a)  //2

闭包作用例子：保存

1. fn():调用完函数，就会释放栈内存
2. f(): 在函数外面有一个变量接收了这个返回值，此时 当前作用域不能销毁

        function fn() {
            var i = 1;
            return function(n) {
                console.log(n + i++)
            }
        }
        var f = fn();
        f(10);   //11     正确:11,10+1=10,之后1为2,因为f(10),在函数fn()外面调用，故函数fn()里的栈内存不销毁,i一直存在
        fn()(10); //12    正确:11 先执行fn(),之后再执行(10),即f(10),执行fn是重新把所有的流程执行一遍，临时不销毁，当返回结果执行完，没有被占用了，就会释放掉
        f(20);  //21      正确:22  //栈内存没有销毁,20+1
        fn()(20);  //22   正确:21 第二次执行fn是重新把所有的流程执行一遍，和第一次没有任何直接的关系,20+2=22

        function fn() {
            var i = 1;
            return function(n) {
                console.log(n + i++)
            }
        }
        var f = fn();
        f(10);  //11
        f(20); //22

        function fn() {
            var i = 1;
            return function(n) {
                console.log(n + i++)
            }
        }
        var f = fn();
        fn()(10); //11
        fn()(20); //21

        function fn() {
            var i = 1;
            return function(n) {
                console.log(n + i++)
            }
        }
        var f = fn();
        fn()(10); //11
        f(20); //21

举一反三

        var i = 1;
        function fn() {
            return function(n) {
                console.log(n + i++)
            }
        }
        var f = fn();
        f(10); //11
        fn()(10); //12
        f(20); //23
        fn()(20); //24

        function fn(i) {
            return function(n) {
                console.log(n + i++)   
            }
            //console.log(i)  //因为return,所以走不到这一hi
        }
        var f = fn(10);
        f(20); //30       正确:30 
        fn(10)(20); //31   正确:30
        f(30); //40        正确:41
        fn(20)(10); // 31  正确:30
        f(40) //50         正确:52