JS预编译

函数声明与表达式
声明：function test(){}
表达式：var outer = function(){}

当然还有一些看不见的属性 [[scope]] 作用域
作用域分为 ： 1>、全局作用域
　　　　　　   2>、局部作用域

js预编译GO对象　

js预编译Go对象
GO对象分为三步走：
1.生成一个GO{global object} ,这里的GO指的就是window
2.将变量存储到Go对象中，变量的value值为undefined
3.全局函数声明的函数名作为Go对象中的key时，函数体整体存入GO对象

js预编译GO （逐步执行，在函数执行的前一刻发生预编译

 1  var a;
 2 
 3         function fun() {
 4 
 5         }
 6 
 7         function abc() {
 8 
 9         }
10 
11         function a() {
12 
13         }
14         console.log(a);
15         var a = 10;
16         console.log(a);
17 （1）会生成一个对象（GO），这个对象封装的就是作用域，称为GO（global object）。当全部挂载完成之后，然后代码在去逐行执行
18     GO={}
19 （2）分析变量声明（var）——变量作为GO对象的属性名，值为undefined
20     GO = {
21         color:undefined;
22         }
23 （3）分析函数声明（function）——函数名作为GO对象的属性名，值为函数体（如果遇到同名，直接覆盖）
24     GO = {
25         a:function a(){};
26         fun:function fun(){}
27                abc:function abc() {}
28     }
29 （4）当走到某一行的时候；a产生了一次赋值；此时GO对象变成了：
30     GO = {
31         a:10;
32         fun:function fun(){}
33                abc:function abc() {}
34     }
35 （5）逐步执行
36     f a(){}  ,   10

预编译AO对象

AO对象分为三步走：
1.生成一个AO{action object}
2.分析参数，形参作为AO对象的属性名，实参作为AO对象的属性值
3.分析var变量声明，变量名作为AO对象的属性名，值为undefined
4.分析函数声明，函数名作为AO对象的属性名，值为函数体，如果遇到同名的直接覆盖

（1）会生成一个对象（AO），这个对象封装的就是作用域，称为AOaction object）。当全部挂载完成之后，然后代码在去逐行执行
    

var num = 10;


        function fun(num) {
            console.log(num);
        }
        fun(100);
        // 1.调用前生成AO对象
        // AO={}
        // 2.分析参数
        // AO={
        //     num : 100;
        //     分析变量声明：没有略过
        //     分析函数声明：没有略过
        // }

（5）逐步执行
100

 // 强调：1.变量可以从里往外一层一层查找使用，但是不能外部的变量内部使用

//        2.AO与GO分辨最简单的方法：未调用时生成GO对象，调用后生成AO对象