本篇文章参考了https://github.com/mqyqingfeng/Blog/issues/5 这位大佬的github。

js在执行一段可执行代码的时候会创建一个执行上下文，对于每一个执行上下文都有三个重要属性。

• 变量对象(Variable object，VO)
• 作用域链(Scope chain)
• this

在全局上下文中,它的变量对象就是全局对象。

函数上下文的变量对象也叫活动对象。因为变量对象不可访问,只有进入一个执行上下文,变量对象别激活后,才能被访问,所以我们叫他活动对象。
执行上下文的执行过程分为两段

进入执行上下文

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

执行代码

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

当进入执行上下文时，这时候还没有执行代码，
变量对象会包括：

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"
}

我们再来看看arguments对象是什么,引用js高程里的话：

调用函数时，会为其创建一个Arguments对象，并自动初始化局部变量arguments，指代该Arguments对象。所有作为参数传入的值都会成为Arguments对象的数组元素。

当查找变量的时候，会先从当前上下文的变量对象中查找，如果没有找到，就会从父级(词法层面上的父级)执行上下文的变量对象中查找，一直找到全局上下文的变量对象，也就是全局对象。这样由多个执行上下文的变量对象构成的链表就叫做作用域链。
我们来看例子。

var scope = "global scope";

  function checkscope() {
    var scope2 = 'local scope';
    return scope2;
  }

  checkscope();

 //1.checkscope被创建
 //保存父元素的变量对象到他的内部属性[[scope]]上
 checkscope.[[scope]] = [globalContext.VO]
// 2.开始执行checkscope函数 创建checkscope的执行上下文,同时chec
 ECStack = [
  checkscopeContext,
  globalContext
 ]
 //3.checkscope函数还需要做一些准备工作才能执行
 // 第一步,复制[[scope]]属性创建作用域链
   checkscopeContext = {
     Scope: checkscope.[[scope]]
  }
  // 第二步,用arguments创建活动对象，并初始化
  checkscopeContext = {
    Ao: {
      arguments: {
        length: 0
      },
       scope2: undefined
    },
     Scope: checkscope.[[scope]]
   }
  // 第三步,把自己的活动对象压入Scope中
   checkscopeContext = {
    AO: {
      arguments: {
         length: 0
       },
       scope2: undefined
    },
    Scope: [AO, checkscope.[[scope]]]
   }
// 4.终于准备工作做完,可以开始执行函数,修改AO的属性值
 checkscopeContext = {
     AO: {
          arguments: {
            length: 0
          },
     scope2: 'local scope'
     },
     Scope: [AO, [[Scope]]]
 }
// 5.查到了scope2的值,返回后函数 执行完毕,把函数上下文从执行上下文中弹出
 ECStack = [
  globalContext
 ];

再来看一个

function a() {
   var aaa = 123;
   function b(){ //函数b的创建是在a的执行上下文准备阶段创建的,这时候就有了a的AO，所以b创建的时候b.[[scope]] = [a.Ao] = 
      console.log(aaa); 
      aaa=234;
};
   b();
   console.dir(aaa);
};
a();

对于上面的例子

1. function b有自己的作用域，内部定义了aaa，所以在它的VO中aaa是undefined
2. function a的VO中也定义了aaa，值是123；
3. function b执行时会顺着它的作用域链做变量查找（reference resolution），先找 到自己定义的aaa，输出是undefined，因为自己的VO在作用域链的第一个位置，最先被查找。
4. 自然，运行时修改的也是b自己AO中的aaa，所以不会影响到a中的aaa。

执行函数的时候才开始创建上下文和执行上下文！！！