window.onload=function(){
        //函数的调用
        fcName();
        fc1();
        var num=fc2(10,20);
        fc3();
        fc4();
    }
    //函数的参数列表 相当于函数入口；return 相当于函数出口
    /*1.function 语句式
      特点：a.创建一次存储在内存中，每次使用从内存中取，效率高
            b.js 解析器会优先解析然后存储在内存中，使用时直接取内存中的（优先解析）
            c.具有函数作用域
    */
    function fcName(){
       alert("function 语句式");
    }
    /*2、函数的直接量式（ECMAScript推荐）
      特点：a.创建一次存储在内存中，每次使用从内存中取，效率高
            b.js 解析器 只是声明了变量fc1 并没有给其赋值 ，只用当程序运行到这里时才会赋值（顺序解析）
            c.具有函数作用域
    */
    var fc1=function(){
        alert("函数的直接量式");
    } 
    /*
      3.Function 构造函数式
      特点：a.每次创建使用后就会销毁 不占用内存但每次使用都要创建 所以效率低
            b.js 解析器 只是声明了变量fc2 并没有给其赋值 ，只用当程序运行到这里时才会赋值（顺序解析）
            c.顶级作用域
    */
    var fc2=new Function("a","b","return a+b;");
    var fc3=new Function("alert('构造函数式')");
    //三种函数的作用域
    var m=0;
    function fc4(){
        var m=1;
        function fc5(){
            alert(m);// 1
        };
        var fc6=function(){
            alert(m);// 1
        }
       var fc3=new Function("return m;");
       fc5();
       fc6();
       alert(fc3());// 0
    }

<script type="text/javascript">
    window.onload=function(){
        fc1(10,20);
    }
    /*
      在js中形参个数可以与实参个数不同
    */
    function fc1(a,b,c){
        var length=fc1.length;//获得形参个数 （不建议使用）
        /*
         arguments 的对象可以访问函数的实际参数（只能在函数内部使用）
        */
        var length2=arguments.callee.length;//获得形参个数(arguments.callee 指向函数本身)
        var args=arguments.length;//实际参数的个数
        var arg1=arguments[0];//获得第一个实际参数
        //在实际开发中我们会先判断参数个数是否相同再执行代码
        if(arguments.callee.length===arguments.length){
           return a+b+c;
        }else{
            return '参数不正确';
        }
    }
    </script>

    window.onload=function(){
        //this 对象是指在运行时基于执行环境所绑定的；this总是指向调用者
    }
    var k=10;
    function test(){
        this.k=20;
    }
    alert(k);// 结果为10；
    test();// 相当于window.test();
    alert(k); // 结果为 20  因为 调用 test()函数的是window对象 所以this指向window对象 this.k 覆盖了 var k；

window.onload=function(){
        // call 、apply 作用一：用于绑定一些函数 用于传递参数、调用
        alert(call1(10,20));//30
        alert(apply1(20,30));// 50
    }
    function sum(x,y){
        return x+y;
    }
    /*
      把 sum函数绑定到this(call1()函数)上
    */
    function call1(x1,y1){
        return sum.call(this,x1,y1);
    }
    function apply1(x2,y2){
        return sum.apply(this,[x2,y2]);
    }

window.onload=function(){
        // call 、apply 作用二：用于扩充作用域
        window.color="red";
        var obj={color:"blue"};
        alert(showColor.call(this));//red 因为this指代调用者window 所以showColor 被绑定在window上
        alert(showColor.call(obj));// blue showColor 被绑定在obj上
    }
    function showColor(){
        return this.color;
    }

window.onload=function(){
        // 模拟 call 、apply 方法的实现方式
        var obj=new Obj(10,30);
        obj.method=test;
        alert(obj.method(obj.x,obj.y));
        delete obj.method;//使用后及时删除 临时调用
    }
    function test(a,b){
        return a*b;
    }
    //自定义的对象
    function Obj(x,y){
        this.x=x;
        this.y=y;
        return x*y;
    }

 //1、最外层执行环境 window对象
     var color1="blue";
     function changeColor(){//每个函数 都是一个执行环境
         var color2="red";
         function swapColor(){//该函数 也会产生一个执行环境（variable obj）
             //该函数内部可以访问 color1 ，color2 
             var color3=color2;
             color2=color1;
             color1=color3;
         }
         //这里可以访问color1、color2 但无法访问 color3
         swapColor();
     }
     //这里只能访问 color1
     changeColor();
     //环境变量 可以一层一层的向上进行追溯 可以访问它的上级环境变量和函数

 //垃圾回收机制 一.标记法 
      function test1(){
              var a=10;
              var b=20;
      }
      /*
        当执行test()函数时变量a、b 会被标记为被使用，一段时间间隔后会标记为未使用
        这是js的垃圾回收机制会回收a、b
      */
      test();
     //垃圾回收机制二：计数法
     function test2(){
         var a=10;// 被计数 count++  count=1；
         var c;
         c=a; //count++  count=2;
         a=50;// count-- count=1；
     }
     //当count=0 时js的垃圾回收机制就会回收 该变量

/*
        在高级程序预言中 for if 语句具备块级作用域的概念
        在js中没有块级作用域的概念 所以会打印 6
    */
        function test1(){
            for(var i=0;i<5;i++){
                alert(i);
            }
            alert(i);// 6
        }
      // 模拟js的块级作用域 使用()
          function test2(){
            (function (){
                for(var i=0;i<5;i++){
                alert(i);
            }
            })();    
            alert(i);// 这样 i在 for循环结束后 就会被 回收 所以程序出错
        }

<script type="text/javascript">
        var name="AA";
        var obj={
            name:"BB",
            getName:function(){
                return function(){
                    return this.name;
                }
            }
        };
        var fg=obj.getName()();//AA
        //拆开写
        var m=obj.getName();//getName()函数 返回的是一个匿名函数 我们定义我为函数m()
        /*
            很显然m()属于window对象 根据作用域链的特点变量只能向上层层追溯
             所以 this.name指向的是window.name, 因此最终打印AA
        */
        var ff=m();//AA

        //如果我希望最终的结果是 BB 该如何改造代码
        var obj1={
            name:"BB",
            getName:function(){
                var o=this;//this 指向obj1 
                return function(){
                    return o.name;
                }
            }
        };
        var m1=obj1.getName();
        var dd=m1();//虽然m1()函数属于window对象但 它内部的name属性属于obj1对象 所以结果是BB

     /*
        闭包：一个函数可以访问另外一个函数作用域中的变量
        封闭性：起到保护变量的作用
     */
     function f(x){
         var temp=x;
         return function(x){
             temp+=x;//temp又被使用 所以在2级作用域后没有被回收
             return temp;
         }
     }
     var te1=f(20);
     var te=te1(2);//22
         te=te1(3);//25
         te=te1(5);//30
    </script>