预编译---

函数作用域初探

1.作用域定义：孙子最舒服。里面可以访问外面函数定义的变量，外面不可以访问里面函数定义的变量

2.js进行三部曲

一，预编译

函数声明整体提升，变量 声明提升。

（1）

// An highlighted block
function test(){
    console.log("a");
}

test();放在该代码前和代码后都可以执行成功

函数声明整体提升：函数整个声明全部放在前面，即function 这一堆全放在script标签后面

（2）

// An highlighted block
function test(){
    console.log(a);
}

var a=123;放在该代码前可以执行成功,放在该代码后结果为undefined（不报错）

变量 声明提升：变量声明放在前面，即var a放在script标签后面,复制不放。

预编译前奏

1.imply global暗示全局变量：即任何变量，如果未经声明就赋值，则此变量就为全局对象（window）所有。a=10 等价于window.a=10

2.一切声明的全局变量，全是window的属性。var a=10 等价于window.a=10

// An highlighted block
function test(){
    var b=123;
}
test();
console.log(window.b);

预编译过程（全局（GO==window）省去第三步）

// An highlighted block
function fn(a){
    console.log(a);
    var a=123;
    //预编译发生在函数执行的前一刻
    console.log(a);
    function a(){}
    console.log(a);
    var b=function(){}
    console.log(b);
    function d(){}
}
fn(1);

1.创建AO对象

AO{
}

2.找形参和变量声明的名，作为AO对象的属性名，值为undefined

AO{
a:undefined
//a写过就不用写了
b:undefined

}

3.将实参形参相统一

AO{
a:1
//a写过就不用写了
b:undefined

}

4.找函数声明

AO{
a:function a(){}
//a写过就不用写了
b:undefined
d:function d(){}
}
函数执行：

举例：

// An highlighted block
function test(a,b){
    console.log(a);
    c=0;
    var c;
    a=3;
    b=2;
    console.log(b);
    function b(){}
    function d(){}
    console.log(b);
}
test(1);

AO{
a:3
b:2
c:0
d:function d（）{}
}
1 2 2

举例：

AO{
a:undefined 1 function a{} 123
b:undefined 234 234 function （）{}
}
f undefined 234 123 123 f

AO和GO

举例：

// An highlighted block
console.log(test)
function test(){
    console.log(test);
    var test=234;
    console.log(test);
    function test(){}
}
test(1);
var test=123;

GO{
test:undefined function test（）{}
}
//执行console.log(test) //fn
//执行test(1)
AO{
tset:undefined 1 function test(){} 234
}
//fn 234

举例：

// An highlighted block
global=100;
function fn(){
    console.log(global);
    global=200;
    console.log(global);
    var global=300;
}
fn();
var global;

GO{
global:undefined; 100
fn:function fn(){…}

}
AO{
global:undefined; 200 300
}
undefined 200

举例：

// An highlighted block
function test(){
    console.log(b);
    if(a){
        var b=100;
    }
    c=234;
    console.log(c);
}
var a;
test();
a=10;
console.log(c);

GO{
a:undefined ; 10
test:function test(){…}
//AO里面没有c就给全局变量
c:234
}
AO{
//不管if
b:undefined;
}

百度面试题：

GO{
bar:function bar(){…}
}
AO{
foo:undefined： function foo(){}
}
//fn

GO{
bar:function bar(){…}
}
AO{
foo:undefined; function foo(){} 10 11
}
//10
举例：

GO{
a:undefined; 100
demo:function demo(){…}
f:123
}
AO{
e:undefined ; 1 function e(){} 2
b:undefined;
c:undefined; (之前的版本，可以在if里面写函数声明，现在不可以了)functuion c(){}
a:undefined; 10
}
//2 undefined undefined(fn) 10 100 123
举例：

//1 flase
typeof（a）//“undefined”
-true//-1
+undefined//NaN
//true+false-flase,后面不打印了
举例：
//先执行后面括号里面的，foo="bar"了，在执行前面window.foo