js基础之 执行上下文栈

javascript语句并非按顺序执行的，而是一段一段执行的。
那么这一段一段是如何划分的呢？
首先js中可执行语句的类型包括：全局代码，函数代码，eval代码
比如当执行一个函数的时候，就会停下来进行准备工作，这个准备工作也就是“执行上下文”。

当然我们的程序中会包含各种各样的函数，那么我们就需要用执行上下文栈（Execution context stack，ECS） 来管理这些函数的执行上下文，下面我们来模拟一下这个过程。
我们将这个栈描述为一个数组，当我们运行代码的时候，最先遇到的肯定是全局上下文，于是我们将它压入到栈中

ECS = [];
ECS.push(globalContext)
	ECS = [globalContext]

紧接着，预到下面的代码

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

function fun2() {
    fun3();
}

function fun1() {
    fun2();
}

fun1();

函数代码的执行原理是： 当执行一个函数的时候，就会创建一个执行上下文，并且压入执行上下文栈，当函数执行完毕的时候，就会将函数的执行上下文从栈中弹出。

ECS .push(f1Context);
ECS .push(f2Context);
ECS .push(f3Context);
ECS .pop(f3Context);
ECS .pop(f2Context);
ECS .pop(f1Context);
// javascript接着执行下面的代码，但是ECStack底层永远有个globalContext

现在基本了解了执行上下文栈如何处理执行上下文的，再看一下下面两段代码

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()();

执行上下文栈：

//1
ECS.push(globalContext);
ECS.push(checkscopeConext);
ECS.push(f Context);
ECS.pop(f)
ECS.pop(checkScope)

//2
ECS.push(globalContext);
ECS.push(checkscopeConext);
ECS.pop(checkScope)
ECS.push(f Context);
ECS.pop(f)

理解完这些之后，我们需要更加深入一下，了解执行上下文内部的一些属性。
对于每个执行上下文，都有三个重要属性：

• 变量对象(Variable object，VO)
• 作用域链(Scope chain)
• this
  我们了解一下 变量对象

变量对象

变量对象是执行上下文中的数据作用域，存储了在上下文中定义的变量和函数声明。
这里还要分开两种情况来说，一个是全局的变量对象，一个是函数上下文的变量对象

全局上下文

先引用一下w3c的概念

全局对象是预定义的对象，作为 JavaScript 的全局函数和全局属性的占位符。通过使用全局对象，可以访问所有其他所有预定义的对象、函数和属性。
在顶层 JavaScript 代码中，可以用关键字 this 引用全局对象。因为全局对象是作用域链的头，这意味着所有非限定性的变量和函数名都会作为该对象的属性来查询。
例如，当JavaScript 代码引用 parseInt() 函数时，它引用的是全局对象的 parseInt 属性。全局对象是作用域链的头，还意味着在顶层 JavaScript 代码中声明的所有变量都将成为全局对象的属性。

全局作用域下的this就是window对象，这个全局对象就是Object实例化的一个对象

console.log(this instanceof Object)//true

上面的概念什么意思呢，就是如果你在全局作用域下创建了一个变量，那么这个变量就成了window的一个属性，你可以通过window这个全局变量去访问，所有的你创建的全局函数、变量什么的都是window这个全局对象的属性，并且都可通过它去访问。

  a = 1;
 console.log(this.a);//1
console.log(this.window.a);//1
 console.log(window.a);//1
//包括像parseInt()这些全局函数，其实都是window的属性
//调用parseInt()其实就是调用window.parseInt()

简单来说，全局上下文中的变量对象就是全局对象

函数上下文

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

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

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

执行过程

• 进入执行上下文
• 代码执行

变量对象会包括：

1. 函数的所有形参 (如果是函数上下文)

• 由名称和对应值组成的一个变量对象的属性被创建
• 没有实参，属性值设为 undefined

2. 函数声明

• 由名称和对应值（函数对象(function-object)）组成一个变量对象的属性被创建
• 如果变量对象已经存在相同名称的属性，则完全替换这个属性

3. 变量声明
   由名称和对应值（undefined）组成一个变量对象的属性被创建；
   如果变量名称跟已经声明的形式参数或函数相同，则变量声明不会干扰已经存在的这类属性

举个例子

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

  b = 3;

}

foo(1);

分析：

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

代码执行

在代码执行阶段，会顺序执行代码，根据代码，修改变量对象的值，
这时候的AO是

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

到这里变量对象的创建过程就介绍完了，让我们简洁的总结我们上述所说：

• 全局上下文的变量对象初始化是全局对象

• 函数上下文的变量对象初始化只包括 Arguments 对象

• 在进入执行上下文时会给变量对象添加形参、函数声明、变量声明等初始的属性值

• 在代码执行阶段，会再次修改变量对象的属性值

思考题

console.log(foo);

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

var foo = 1;

会打印函数，而不是 undefined 。

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