JavaScript深入系列（执行上下文栈、变量对象）-读后总结（二）

整理自冴羽大佬的博客，仅供自己学习使用。
链接: 冴羽博客地址

执行上下文栈

JavaScript引擎并非一行一行的分析和执行程序，而是一段一段的分析执行。当一段代码执行是会进入一个准备工作，例如变量提升和函数提升。

function foo() {
    console.log('foo1');
}

foo();  // foo2

function foo() {
   console.log('foo2');
}

foo(); // foo2

这段代码执行时进行了函数提升，因此打印了两个foo2,相当于：

function foo() {
    console.log('foo1');
}

function foo() {
   console.log('foo2');
}

foo();  // foo2

foo(); // foo2

可执行代码

JavaScript的可执行代码有3种：

• 全局代码
• 函数代码
• eval代码

执行上下文

当执行一个函数的时候，就会进行准备工作，这里的准备工作也叫执行上下文(execution context)

执行上下文栈

JavaScript引擎创建了执行上下文栈(Execution context stack,ECS)来管理执行上下文。

为了模拟执行上下文栈的行为，定义执行上下文栈是一个数组：

ECStack = [];

当JavaScript开始解释执行的时候，最先遇到的是全局代码，所以首先会向栈中压入一个全局执行上下文，使用globalContext表示它，并且只有当整个程序执行结束时ECStack才会清空，因此执行结束之前ECStack底部永远有个globalContext:

ECStack = [
    globalContext
];

现在 JavaScript 遇到下面的这段代码了：

function fun3() {
    console.log('fun3')
}

function fun2() {
    fun3();
}

function fun1() {
    fun2();
}

fun1();

当执行一个函数时，就会创建一个执行上下文，并且压入上下文栈，当函数执行完毕时，就会将该执行上下文从栈中弹出。

// 伪代码

// fun1()
ECStack.push(<fun1> functionContext);

// fun1中竟然调用了fun2，还要创建fun2的执行上下文
ECStack.push(<fun2> functionContext);

//fun2还调用了fun3！
ECStack.push(<fun3> functionContext);

// fun3执行完毕
ECStack.pop();

// fun2执行完毕
ECStack.pop();

// fun1执行完毕
ECStack.pop();

// javascript接着执行下面的代码，但是ECStack底层永远有个globalContext

执行上下文的生命周期

一个执行上下文的生命周期可以分为两个阶段。

1. 创建阶段

在这个阶段中，执行上下文会分别创建变量对象，建立作用域链，以及确定this的指向。

2. 代码执行阶段

创建完成之后，就会开始执行代码，这个时候，会完成变量赋值，函数引用，以及执行其他代码。

思考题

下面两段代码的执行上下文栈的变化有何不同？

var scope = "global scope";
function checkscope(){
    var scope = "local scope";
    function f(){
        return scope;
    }
    return f();
}
checkscope();

var scope = "global scope";
function checkscope(){
    var scope = "local scope";
    function f(){
        return scope;
    }
    return f;
}
checkscope()();

第一段代码的执行上下文栈的变化：

ECStack.push(<checkscope> functionContext);
ECStack.push(<f> functionContext);
ECStack.pop();
ECStack.pop();

第二段代码的执行上下文栈的变化：

ECStack.push(<checkscope> functionContext);
ECStack.pop();
ECStack.push(<f> functionContext);
ECStack.pop();

变量对象

变量对象是与执行上下文相关的数据作用域，存储在上下文中定义的变量和函数声明。

对于每个执行上下文，都有三个重要属性：

• 变量对象（Variable object, VO）
• 作用域链（Scope chain）
• this

全局上下文

全局对象：

全局对象是预定义的对象，作为 JavaScript 的全局函数和全局属性的占位符。通过使用全局对象，可以访问所有其他所有预定义的对象、函数和属性。

在顶层 JavaScript 代码中，可以用关键字 this 引用全局对象。因为全局对象是作用域链的头，这意味着所有非限定性的变量和函数名都会作为该对象的属性来查询。

例如，当JavaScript 代码引用 parseInt() 函数时，它引用的是全局对象的 parseInt 属性。全局对象是作用域链的头，还意味着在顶层 JavaScript 代码中声明的所有变量都将成为全局对象的属性。

在客户端JavaScript中，全局对象就是Window对象。简单的来说全局上下文中的变量就是全局对象。

函数上下文

在函数上下文中，用活动对象(activation object, AO)表示变量对象

活动对象和变量对象其实是一个东西，只是活动对象不可以在JavaScript环境中访问，只有当进入一个执行上下文中，这个执行上下文的变量对象才会被激活，所以叫activation object，而只有被激活的变量对象，即活动对象上的各种属性才能访问。

活动对象在进入函数上下文时被创建，通过函数的arguments属性初始化。arguments属性值是Arguments对象。

AO 实际上是包含了 VO 的。因为除了 VO 之外，AO 还包含函数的 parameters，以及 arguments 这个特殊对象。也就是说 AO 的确是在进入到执行阶段的时候被激活，但是激活的除了 VO 之外，还包括函数执行时传入的参数和 arguments 这个特殊对象。
AO = VO + function parameters + arguments

执行过程

执行上下文的代码会分成两个阶段进行处理：分析和执行，也可叫做：

1. 进入执行上下文
2. 代码执行

进入执行上下文

此时还没有执行代码

变量对象会包括：

1. 函数的所有形参（如果是函数上下文）
   • 由名称和对应值组成的一个变量对象属性被创建
   • 没有实参的形参属性值被设为undefined
2. 函数声明
   • 由名称和对应值(函数对象function-object)组成一个变量对象属性被创建
   • 如果该变量对象已经存在相同名称属性，则替换该属性的函数对象
3. 变量声明
   • 由名称和对应值(此时为undefined)组成一个变量对象属性被创建
   • 如果变量名称和已经声明的形参或者函数相同，则变量声明不会干扰到已存在的这类属性

例子：

function foo(a) {
  var b = 2;
  function c() {}
  var d = function() {};

  b = 3;

}

foo(1);

进入执行上下文后，此时AO是：

AO = {
    arguments: {
        0: 1,
        length: 1
    },
    a: 1,
    b: undefined,
    c: reference to function c(){},
    d: undefined
}

代码执行

在代码执行阶段，会顺序执行代码，根据代码修改变量对象的值
当代码执行完后，此时AO是：

AO = {
    arguments: {
        0: 1,
        length: 1
    },
    a: 1,
    b: 3,
    c: reference to function c(){},
    d: reference to FunctionExpression "d"
}

综上所述：

1. 全局上下文的变量对象初始化是全局对象
2. 函数上下文的变量对象初始化只包括Arguments对象
3. 在进入执行上下文是会给变量对象添加形参、函数声明、变量声明等初始值
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 中。

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

AO = {
    arguments: {
        length: 0
    }
}

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

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

第二题：

console.log(foo);

function foo(){
    console.log("foo");
}

var foo = 1;

会打印函数，而不是 undefined 。

这是因为在进入执行上下文时，首先会处理函数声明，其次会处理变量声明，如果变量名称跟已经声明的形式参数或函数相同，则变量声明不会干扰已经存在的这类属性。