前言

当 JS 执行一段可执行代码时，会创建执行上下文，对于每个执行上下文，都有三个重要属性：

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

作用域链

在变量对象那文中讲到，当查找变量的时候，会先从当前上下文的变量对象中查找，如果没有找到，就会从父级执行上下文中查找，一直找到全局对象中。这样有多个执行上下文的变量对象构成的链表就叫做作用域链。

函数创建

函数的作用域在函数定义的时候就决定了，这是因为函数有一个内部属性 [[scope]] ，当函数创建的时候，就会保存所有父变量对象到其中，你可以理解 [[scope]] 就是所有父级变量对象的层级链，但是 [[scope]] 并不代表完整的作用域链：

function foo() {
  function bar() {
    
  }
}

/*
foo.[[scope]] = [
	globalContext.VO
]

bar.[[scope]] = [
	fooContext.AO,
	globalContext.VO
]
*/

函数激活

当函数激活时，进入函数上下文创建 AO/VO 后，就会将活动对象添加到作用链的顶端，这时候执行上下文的作用域链我们命名为 Scope：

Scope = [AO].concat([[Scope]])

至此，作用域链创建完毕。

捋一捋

以下面的例子为例，结合之前讲的变量对象和执行上下文栈，我们总结一下函数执行上下文中作用域链和变量对象的创建过程：

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

执行过程如下：

1. checkscope 函数被创建，保存作用域链到内部属性 [[scope]]

   checkscope.[[scope]] = [
     globalContext.VO
   ]
   

2. 执行 checkscope 函数，创建 checkscope 函数执行上下文，并且压栈

   ECStack = [
     checkscopeContext,
     globalContext
   ]
   

3. checkscope 不会立即执行，而是开始准备阶段

   1. 第一步：复制函数 [[scope]] 属性创建作用域链

      checkscopeContext = {
          Scope: checkscope.[[scope]],
      }
      

   2. 第二步：用 arguments 创建活动对象，随后初始化活动对象，加入形参、函数声明、变量声明

      checkscopeContext = {
          AO: {
              arguments: {
                  length: 0
              },
              scope2: undefined
          }，
          Scope: checkscope.[[scope]],
      }
      

   3. 第三步：将 AO 压入 checkscope 作用域链顶端

      checkscopeContext = {
          AO: {
              arguments: {
                  length: 0
              },
              scope2: undefined
          },
          Scope: [AO, [[Scope]]]
      }
      

   4. 准备工作完成，开始执行函数，随着函数执行修改 AO 的属性值

      checkscopeContext = {
          AO: {
              arguments: {
                  length: 0
              },
              scope2: 'local scope'
          },
          Scope: [AO, [[Scope]]]
      }
      

   5. 函数执行完毕后，函数上下文从执行上下文栈中出栈

      ECStack = [
          globalContext
      ];