<script>
    function fn1(){
        var a = 2;
        function fn2(){//執(zhí)行函數(shù)定義就會產(chǎn)生閉包(不用調(diào)用內(nèi)部函數(shù))
            console.log(a);
        }
        //新版的chrome需要返回一下內(nèi)部函數(shù)才會顯示閉包
        return fn2()
    }
    fn1()
</script>

<script>
    // 將函數(shù)作為另一個函數(shù)的返回值
    function fn1(){
        var a = 2;
        function fn2(){//
            a++;
            console.log(a);
        }
        return fn2 //將一個內(nèi)部函數(shù)作為一個外部函數(shù)的返回值返回
    }
    var f = fn1()
    //整個過程產(chǎn)生了一個閉包，主要看你產(chǎn)生了幾個內(nèi)部函數(shù)對象，調(diào)用了幾次外部函數(shù)
    //閉包的特點就是函數(shù)內(nèi)部的變量會一直存在于內(nèi)存中，不會立即釋放。
    f()//3   這里的f()是調(diào)用了內(nèi)部函數(shù)
    f()//4
</script>

<script>
    // 將函數(shù)作為實參傳遞給另一個函數(shù)調(diào)用
    function showDelay(msg,time){
        //setTimeout 的第一個參數(shù)是函數(shù)，符合閉包的規(guī)則
        setTimeout(function(){
            alert(msg)
        },time)
    }
    showDelay('張三',2000)
</script>

<script>
    function fn1 () {
        //此時閉包就已經(jīng)產(chǎn)生了(函數(shù)提升，內(nèi)部函數(shù)對象已經(jīng)創(chuàng)建了)
        var a = 2;
        function fn2 () {//
            a++;
            console.log(a);
        }
        return fn2 //將一個內(nèi)部函數(shù)作為一個外部函數(shù)的返回值返回
    }
    var f = fn1()
    f()//3   
    f()//4
    f = null //閉包死亡(包含閉包的函數(shù)對象成為垃圾對象)
</script>

//myModule.js 文件
function myModule(){
    // 私有數(shù)據(jù)
    var msg = 'My Module'
    function showUpper(){
        console.log('showUpper' +msg.toUpperCase());
    }
    function showLow(){
        console.log('showLow' +msg.toLowerCase());
    }
    //向外暴露對象(給外部使用的方法)
    return {
        showUpper:showUpper,
        showLow:showLow
    }
}
//index.html文件
<script src="./myModule.js"></script>
<script>
    var module = myModule()
    module.showUpper()
    module.showLow()
</script>
 

//myModule2.js文件
(function(){
    // 私有數(shù)據(jù)
    var msg = 'My Module'
    // 操作數(shù)據(jù)的函數(shù)
    function showUpper(){
        console.log('showUpper' +msg.toUpperCase());
    }
    function showLow(){
        console.log('showLow' +msg.toLowerCase());
    }
    //向外暴露對象(給外部使用的方法)
    window.myModule2 = {
        showUpper:showUpper,
        showLow:showLow
    }
})()
//index.js文件
<script src="./myModule2.js"></script>
<script>
    myModule2.showUpper()
    myModule2.showLow()
</script

<script>
    function fn1(){
        var arr = new Array[100000]
        function fn2(){
            console.log(arr.length);
        }
        return fn2
    }
    var f = fn1()
    f()
    //不用閉包或者回收閉包
    f = null//讓內(nèi)部函數(shù)成為垃圾對象 --> 回收閉包
</script>

<script>
    var obj = {}
    for(var i=0;i<10000;i++){
        obj[i]=new Array(1000000)
        console.log('------');
    }
</script>

<script>
    //意外的全局變量
    function fn(){
        a = 10;
        console.log(a);
    }
    // 調(diào)用函數(shù)雖然能打印a，但是a并沒有被釋放掉。一不注意就設(shè)置了一個全局變量
    fn()
    //沒有及時清理計時器或回調(diào)函數(shù)
    var intervalId = setInterval(function(){ //啟動循環(huán)定時器后不清理
        console.log('--------');
    },2000)
    // clearInterval(intervalId)
    //閉包
    function fn1(){
        var a = 2 //閉包 a 并沒有被釋放掉
        function fn2(){
            console.log(++a)
        }
        return fn2
    }
    var f = fn1()
    f()
    // f = null 不執(zhí)行這條語句，a的值一直在
</script>

<script>
    // 案例一：
    var name = "this is Window"
    var object = {
        name:"this is Object",
        getName:function(){
            return function(){
                return this.name
            }
        }
    }
    //閉包的this只能是全局，若在當前作用域中定義了this，就直接使用定義的this，若沒定義，則需要一層層向外找，直到全局為止
    //本題是沒有閉包的
    alert(object.getName()())//this is Window
    // 案例二：
    var name1 = "this is Window"
    var object1 = {
        name1:"this is Object",
        getName:function(){
            //定義的that形成了閉包，內(nèi)部函數(shù)引用了外部函數(shù)的變量，而this指向的是object，所以返回的是object中的name1
            var that = this;
            return function(){
                return that.name1
            }
        }
    }
    alert(object1.getName()())// this is Object
</script>

<script>
    //沒有使用閉包的話，數(shù)據(jù)是沒有保留的，所以n傳遞給o之后，下次運算o值還是上次的值不會發(fā)生改變
    function fun(n,o){
        console.log(o);
        return{
            fun:function(m){
                return fun(m,n)
            }
        }
    }
    //在執(zhí)行fun(0)之后，n被之前的n=0,一直被調(diào)用
    var a = fun(0); //閉包里面的n傳入了0
    a.fun(1); 
    a.fun(2);
    a.fun(3)//undefined,0,0,0
    //鏈式執(zhí)行會導致n的改變，n是前面函數(shù)執(zhí)行的形參
    var b = fun(0).fun(1).fun(2).fun(3)//undefined,0,1,2
    //c.fun(2)、c.fun(3)都調(diào)用了fun(1)留下的閉包n
    var c = fun(0).fun(1); 
    c.fun(2); 
    c.fun(3)//undefined,0,1,1
</script>