上下文

函数上下文(AO)

当进入执行上下文时，这时候还没有执行代码，

变量对象会包括：

函数的所有形参和声明变量 (如果是函数上下文)

1.由形参和声明变量的名称为属性被创建；

2.没有实参，属性值设为 undefined

实参赋值给形参

1.找到形参名称的属性，将其属性值由undefined改为实参值

函数声明

1.由名称和对应值（函数对象(function-object)）组成一个变量对象的属性被创建

2.如果变量对象已经存在相同名称的属性，则完全替换这个属性

 

最后在执行函数

例子：

function test(a){
    console.log(a);
    var a=1;
    console.log(a);
    function a(){}
    console.log(a);
    console.log(b);
    var b=function(){}
    console.log(b);
    function c(){}
}
test(2)

1.AO = {
    a: undefined,
    b: undefined,
}
2.AO = {
    a: undefined->
    2,
    b: undefined,
}
3.AO = {
    a: undefined ->
        2 ->
        function a(){},
    b: undefined,
    c: function c(){},
}
4.AO = {
    a: undefined ->
        2 ->
        function a(){}->
        1,
    b: undefined -> function b(){},
    c: function c(){},
}

 

function test(){
    return a;
    a=1;
    function a(){}
    var a=2;
}
console.log(test()); // function a(){}

AO={
    a:undefined -> function a(){}
}

 

console.log(test()); //2
function test() {
    a = 1;
    function a() { }
    var a = 2;
    return a;
}
AO = {
    a: undefined -> function a() { }->1->2
}

 

a=1;
function test(e){
    function e(){}
    arguments[0]=2;
    console.log(e); // 2
    if(a){
        var b=3;
    }
    var c;
    a=4;
    var a;
    console.log(b); // undefined
    f=5;
    console.log(c); // undefined
    console.log(a); // 4
}
var a;
test(1);
console.log(a); // 1
console.log(f); // 5

GO={
    a:undefined ->1,
    test:function test(){...},
    f:5
}
AO={
    e:undefined->1->function e(){}->2,
    b:undefined,
    c:undefined,
    a:undefined->4,
}

 

function foo() {
    console.log(a);
    a = 1;
}

foo(); // ???

function bar() {
    a = 1;
    console.log(a);
}
bar(); // ???

第一段会报错：Uncaught ReferenceError: a is not defined。

第二段会打印：1。

这是因为函数中的 "a" 并没有通过 var 关键字声明，所有不会被存放在 AO 中。

a=1是执行阶段，不存在变量提升在GO里。

第一段执行 console 的时候， AO 的值是：

AO = {
    arguments: {
        length: 0
    }
}

没有 a 的值，然后就会到全局去找，全局也没有，所以会报错。

当第二段执行 console 的时候，全局对象已经被赋予了 a 属性，这时候就可以从全局找到 a 的值，所以会打印 1。

 

全局上下文(GO)

// 函数声明整体提升，变量只有声明提升，赋值是不提升的

var a=1;// 是有两个步骤的，一是声明变量，二是变量赋值；

test(); // 1
function test(){
  conslo.log(1);  
}
console.log(a); // undefined
var a; 

 

 思考，为啥执行的位置不一样；会产生这种变化变化？

function getName() {
    console.log(1);
}
var getName = function () {
    console.log(2);
}
getName(); // 2
var a=1;
function a(){
　　console.log(2);
}
console.log(a); // 1

 

getName(); // 1
function getName() {
    console.log(1);
}
var getName = function () {
    console.log(2);
}

console.log(a); // 函数a
var a=1;
function a(){
　　console.log(2);
}

 

函数里面没有声明的变量，都是在window下的，不管是多少层函数内；

// GO与AO类似，就是没有参数

 1.找变量；

2.找函数声明

2.执行

GO={
    a:undefined->function a(){}->1
}