JS全局的预编译三部曲

全局的预编译三部曲：

1、生成了一个 GO 的对象 Global Object（window 就是 GO）

2、找形参和变量声明，将变量和形参名作为 GO 属性名，值为 undefined

3、在函数体里面找函数声明，值赋予函数体

例 console.log(a);

var a = 123;

function a (){}

答案过程，GO{

a : undefined

}

函数声明 GO{

a : function a (){}

}

执行 var a = 123;变 GO{

a : 123

}

执行 console.log(a);就是 123

GO === window， GO 和 window 是一个东西

console.log(a);和 console.log(window.a);和 console.log(go.a);是一样

任何全局变量都是 window 上的属性

没有声明就是赋值了，归 window 所有，就是在 GO 里面预编译

例 function test(){

var a = b =123;

console.log(window.b);

}

test();

答案 a 是 undefined，b 是 123

先生成 GO{

b : 123

}

再有 AO{

a : undefined

}

先生成 GO 还是 AO?

想执行全局，先生成 GO，在执行 test 的前一刻生成 AO

在几层嵌套关系，近的优先，从近的到远的，有 AO 就看 AO，AO 没有才看 GO

例 console.log(test);

function test(test){

console.log(test);

var test = 234;

console.log(test);

function test(){

}

}

test(1);

var test = 123;

答题过程:想执行全局,先有 GO,GO{

test : undefined

}

发现有函数声明 GO{

test : function (){

.....

}

}

执行 console.log(test)，

执行 test(1)之前生成 AO{

test : function (){}

}

执行 var test = 234;变成 234

AO 上面有就用 AO 的，没有就看 GO 的

例 var global = 100;

function fn(){

console.log(global);

}

fn();

答题过程 GO{

global : undefined,

fn : function(){.....}

}

执行 var global = 100;变 GO{

global : 100,

fn : function(){.....}

}

不看 function fn(){...}里面的东西

看AO啥也没有，故看GO

执行 fn()之前 AO{

访问 GO 的 global

}

答题过程，GO{

global : undefined

fn : undefined(没用可以不写)

}

变 GO{

global : 100

fn : undefined

}

之后就是AO{}，但是fn（）里有变量声明，就用fn（），而不用GO

执行 fn()之前，AO{

global : undefined

}

执行结果是 undefined，200

例 function bar(){

return foo;

foo = 10;

function foo(){}

var foo = 11;

}

console.log(bar());

答案：function foo(){}

如果在第一行 return foo，下面有 foo 这个函数，一定打印这个函数

例 console.log(bar());

function bar(){

foo = 10;

function foo(){}

var foo = 11;

returm foo;

}

答案 11

例 console.log(b);

var b = function (){}

答案是 undefined

例现在在 if 里面定义函数声明 function 是不允许的，但是过去可以，下面就是过去

的旧题，按可以来做

GO{

a : undefined

}

GO{

a : undefined

demo : function (){}

}

开始执行 a=100，GO{

a : 100

demo : function (){}

}

AO{

e : undefined,

b : undefined,

c : undefined,

a : undefined

}

形参实参相统一，AO{

e : 1,

b : undefined,

c : undefined,

a : undefined

}

赋值 AO{

e : function e (){},

b : undefined,

c : undefined,------旧规则里面可以提出 function(){}

a : undefined

}

执行 arguments[0] = 2;实参列表和传参是否相映射，变 AO{

e : 2,

b : undefined,

c : undefined,

a : undefined

}

执行 console.log(e);答案 2

if(a)由于 a 在 AO 里面是 undefined，所以不走 if

执行 a = 10;变 AO{

e : 2,

b : undefined,

c : undefined,

a : 10

}

执行 console.log(b)，答案 undefined

执行 f = 123，变 GO{

a : 100,

demo : function (){},

f : 123

}

执行 console.log(c); 之前打印 function(){}，改语法后打印 undefined

执行 console.log(a); 答案 10

执行 console.log(a); 因为在外面是全局的，答案 100

执行 console.log(a); 答案 123