闭包

//声明一个闭包
    function f1()
    {
        var week="Sunday";
        function f2()
        {
            console.log('星期：'+week);
        }
        return f2;
    }
    var ff=f1();
    //以上代码已经形成一个闭包，其是一个函数，ff就是这个函数
    //f1执行后返回f2函数，函数对象对ff进行赋值（引用赋值）
    //调用闭包函数ff，使其发生执行
    //ff和f2是同一个function的两个不同名字，f2是局部变量,ff是全局变量
    //因此，该function可以在内部、外部环境同时访问
    //无论是内部还是外部环境，只要function执行，就具体上下级环境没有直接关系
    //内部的week永远都是我们自己AO活动对象的属性
    //因此，只要该function能够访问到，就无视内部变量的来源，其就是函数AO活动对象的属性，是固化好的。
    ff();//Sunday

//闭包使用规则:
   //同一个闭包机制可以创建多个闭包函数出来，它们彼此没有联系，都是独立的，并且每个闭包可以保存自己个性化的信息。
   function f1(num){
    //外部变量：变量、参数、函数
    //var num=100;//num就是f1函数的形参，也是其局部变量
    function f2(){//f2可以访问f1中的变量num
        console.log("数字："+num);//100
    }
    return f2;
   }
 /*  var fa=f1(100);
   fa();//100
   var fb=f1(110);
   fb();//110*/
   //闭包机制每调用一次，就生成一个闭包函数
    var fa=f1(100);
    var fb=f1(110);
    var fc=f1(120);
   fa();//100
   fb();//110
   fc();//120

function f1(num){
    //外部变量：变量、参数、函数
    var num=200;
    function f2(){
        console.log("数字："+num++);
        //num++是先把结果返回再加
        //++num是先相加再返回结果
    }
    return f2;
   }
   //生成闭包
   var fa=f1();
   fa();//200
   fa();//201

   var fb=f1();//fa、fb两个闭包之间没有联系
   fb();//200
   fb();//201

闭包事件操作

<h2>闭包事件操作</h2>
    <ul>
        <li>奔驰</li>
        <li>宝马</li>
        <li>奥迪</li>
    </ul>

<pre name="code" class="javascript">//给li设置mouseover和mouseout事件，鼠标滑过高亮显示当前行
     window.onload=function(){
        var lis=document.getElementsByTagName("li");
        for(var i=0;i<lis.length;i++)
        {
            lis[i].onmouseover=over(i);//闭包
            //lis[0].onmouseover=function(){lis[i].style.background="pink";};
            //lis[1].onmouseover=function(){lis[i].style.background="pink";};
            //lis[2].onmouseover=function(){lis[i].style.background="pink";};
            //此处只是声明但是并没有执行，当执行的时候i已经定格为3
            lis[i].onmouseout=out(i);//闭包
        }
        function over(n){
            function f2(){
                lis[n].style.background="pink";
            }
            return f2;
        }
        function out(n){
            function f2(){
                lis[n].style.background="";
            }
            return f2;
        }
     };
    </script>

//闭包案例--创建数组
    var arr=new Array();
    for(var i=0;i<4;i++){
        arr[i]=function(){
            console.log(i);
        }
        //alert(arr[i]);//弹出function(){console.log(i)};说明下面的声明解释是正确的
        /*
        以上代码相当于声明了一下代码：
        for(var i=0;i<4;i++){
    arr[0]=function(){console.log(i);}
    arr[1]=function(){console.log(i);}
    arr[2]=function(){console.log(i);}
    arr[3]=function(){console.log(i);}*/
    //当真正执行的时候i已经变为4
    }
    arr[2]();//4
    arr[1]();//4
    arr[0]();//4
    arr[3]();//4
    //以上4个数组元素函数调用没有输出理想的信息，而是输出4

var arr=new Array();
   for(var i=0;i<4;i++){
    //arr[i]=闭包;
    arr[i]=f1(i);//通过调用f1()闭包机制，生成多个独立函数,并且每个函数的i变量都是不同值
    /*
    arr[0]=f1(0)=function f2(){console.log(0);};
    arr[1]=f1(1)=function f2(){console.log(1);};
    arr[2]=f1(2)=function f2(){console.log(2);};
    arr[3]=f1(3)=function f2(){console.log(3);};
     */
   }
   function f1(n){
    function f2(){
        console.log(n);//可以访问外函数f1的形参n
    }
    return f2;
   }
    arr[2]();//2
    arr[1]();//1
    arr[0]();//0
    arr[3]();//3

Javascript垃圾回收方法

标记清除（mark and sweep）

这是JavaScript最常见的垃圾回收方式，当变量进入执行环境的时候，比如函数中声明一个变量，垃圾回收器将其标记为“进入环境”，当变量离开环境的时候（函数执行结束）将其标记为“离开环境”。

垃圾回收器会在运行的时候给存储在内存中的所有变量加上标记，然后去掉环境中的变量以及被环境中变量所引用的变量（闭包），在这些完成之后仍存在标记的就是要删除的变量了

引用计数(reference counting)

在低版本IE中经常会出现内存泄露，很多时候就是因为其采用引用计数方式进行垃圾回收。引用计数的策略是跟踪记录每个值被使用的次数，当声明了一个 变量并将一个引用类型赋值给该变量的时候这个值的引用次数就加1，如果该变量的值变成了另外一个，则这个值得引用次数减1，当这个值的引用次数变为0的时 候，说明没有变量在使用，这个值没法被访问了，因此可以将其占用的空间回收，这样垃圾回收器会在运行的时候清理掉引用次数为0的值占用的空间。

在IE中虽然JavaScript对象通过标记清除的方式进行垃圾回收，但BOM与DOM对象却是通过引用计数回收垃圾的，也就是说只要涉及BOM及DOM就会出现循环引用问题。