调用JS函数包括两部分在执行：1.词法分析 2.执行语句  
    例1:*/

          function test(x,y){ 
                 function x(){
                     alert(x);
                }
                x();
                alert(x);
          }
          test(100);

    词法分析：
    1.函数执行时候，生成Active Object对象
    2.AO.x=undefined AO.y=undefined   (形参的值都将为undefined)
    3.test(100) 只给一个实参 那么AO.x=100 AO.y值不变
    4.遇到function x 那么AO.x=function x(){alert(x)} (可以理解为函数声明优先级大于上面的"赋值方式")
    
    执行：
    1
        1.1  x() 执行函数x 同样也分为两部分：词法分析和执行
        1.2  由于在x的AO对象中没有x 那么它将到沿着作用域链到上一层找 得到test的AO.x的值并输出
    2 alert(x) 在当前对象AO对象中得到x的值

    最后得到输出结果一样

    例2：

       function test(x,y){ 
            var x=15;
                 function x(){
                     alert(x);
                }
                x();
                alert(x);
          }
          test(100);
    //result  TypeError: x is not a function x();

    
    思路按照上一个例子中的解释 不过在执行过程中 var x=15; 重新覆盖了x的值，改变了数据类型，自然x()不是函数了

    /*例3：     

          function a(){     
                    alert(b);   //函数b的函数体的所有内容
                    b();
                     function b(){
                        c()
                        function c(){
                            d();
                            function d(){
                              alert(a); //函数a的函数体的所有内容
                              
                            }
                        }
                     }
                }          
                a();

               
              词法分析：
                     1.函数调用时候 生成Active Object对象(嵌套调用时候各自生成AO对象)
                     2.以a为例 它词法分析过程中 AO.b=函数b函数体内的所有内容 其它流程都一样
              执行过程：
                    1.alert(b)  得到属于a的AO对象中B的值(即函数B的函数体内容)
                    2.alert(a)  由于所在的d的AO对象中找不到a的值 只能在作用域链沿上查找(就近找值，即查找每层函数的AO对象中是否含有需要查找的变量)