(ES5版)深刻理解 JavaScript 执行上下文和执行栈

译者序

最近在研究 JavaScript 基础性的东西，可是看到对于执行上下文的解释我发现有两种，一种是执行上下文包含：scope(做用域)、variable object(变量对象)、this value(this 值)，另一个种是包含：lexical environment(词法环境)、variable environment(变量环境)、this value(this 值)。javascript

后面我查阅了很多博客以及 ES3 和 ES5 的规范才了解到，第一种是 ES3 的规范，经典书籍《JavaScript 高级程序设计》第三版就是这样解释的，也是网上广为流传的一种，另外一种是 ES5 的规范。前端

而后我接着又去翻了 ES2018 中的，发现又有变化了，已经增长了更多的内容了，考虑到这部份内容颇为复杂，准备后面再进行总结分享，查资料的时候看到这篇讲执行上下文(ES5 )的还不错，因此就翻译出来先分享给你们。java

之后看到变量对象、活动对象知道是 ES3 里面的内容，而若是是词法环境、变量环境这种词就是 ES5 之后的内容。web

如下是正文：面试

什么是执行上下文？

简而言之，执行上下文是计算和执行 JavaScript 代码的环境的抽象概念。每当 Javascript 代码在运行的时候，它都是在执行上下文中运行。编程

执行上下文的类型

JavaScript 中有三种执行上下文类型。浏览器

全局执行上下文 — 这是默认或者说基础的上下文，任何不在函数内部的代码都在全局上下文中。它会执行两件事：建立一个全局的 window 对象（浏览器的状况下），而且设置 this 的值等于这个全局对象。一个程序中只会有一个全局执行上下文。
函数执行上下文 — 每当一个函数被调用时, 都会为该函数建立一个新的上下文。每一个函数都有它本身的执行上下文，不过是在函数被调用时建立的。函数上下文能够有任意多个。每当一个新的执行上下文被建立，它会按定义的顺序（将在后文讨论）执行一系列步骤。
Eval 函数执行上下文 — 执行在 eval 函数内部的代码也会有它属于本身的执行上下文，但因为 JavaScript 开发者并不常用 eval，因此在这里我不会讨论它。

执行栈

执行栈，也就是在其它编程语言中所说的“调用栈”，是一种拥有 LIFO（后进先出）的数据结构，被用来存储代码运行时建立的全部执行上下文。微信

当 JavaScript 引擎第一次遇到你的脚本时，它会建立一个全局的执行上下文而且压入当前执行栈。每当引擎遇到一个函数调用，它会为该函数建立一个新的执行上下文并压入栈的顶部。数据结构

引擎会执行处于栈顶的执行上下文的函数。当该函数执行结束时，执行上下文从栈中弹出，控制流程到达当前栈中的下一个上下文。闭包

让咱们经过下面的代码示例来理解：

let a = 'Hello World!';

functionfirst() {
  console.log('Inside first function');
  second();
  console.log('Again inside first function');
}

functionsecond() {
  console.log('Inside second function');
}

first();
console.log('Inside Global Execution Context');

上述代码的执行上下文栈。

当上述代码在浏览器加载时，JavaScript 引擎建立了一个全局执行上下文并把它压入当前执行栈。当遇到 first() 函数调用时，JavaScript 引擎为该函数建立一个新的执行上下文并把它压入当前执行栈的顶部。

当从 first() 函数内部调用 second() 函数时，JavaScript 引擎为 second() 函数建立了一个新的执行上下文并把它压入当前执行栈的顶部。当 second() 函数执行完毕，它的执行上下文会从当前栈弹出，而且控制流程到达下一个执行上下文，即 first() 函数的执行上下文。

当 first() 执行完毕，它的执行上下文从栈弹出，控制流程到达全局执行上下文。一旦全部代码执行完毕，JavaScript 引擎从当前栈中移除全局执行上下文。

怎么建立执行上下文？

到如今，咱们已经看过 JavaScript 怎样管理执行上下文了，如今让咱们了解 JavaScript 引擎是怎样建立执行上下文的。

建立执行上下文有两个阶段：1) 建立阶段 和 2) 执行阶段。

建立阶段

在 JavaScript 代码执行前，执行上下文将经历建立阶段。在建立阶段会发生三件事：

this 值的决定，即咱们所熟知的 this 绑定。
建立 词法环境组件。
建立 变量环境组件。

因此执行上下文在概念上表示以下：

ExecutionContext = {
  ThisBinding = <this value>,
 LexicalEnvironment = { ... },
 VariableEnvironment = { ... },
}

this 绑定：**

在全局执行上下文中，this 的值指向全局对象。(在浏览器中，this引用 Window 对象)。

在函数执行上下文中，this 的值取决于该函数是如何被调用的。若是它被一个引用对象调用，那么 this 会被设置成那个对象，不然 this 的值被设置为全局对象或者 undefined（在严格模式下）。例如：

let foo = {
  baz: function() {
  console.log(this);
  }
}

foo.baz();   // 'this' 引用 'foo', 由于 'baz' 被
             // 对象 'foo' 调用

let bar = foo.baz;

bar();       // 'this' 指向全局 window 对象，由于
             // 没有指定引用对象

词法环境

官方的 ES6^[1] 文档把词法环境定义为

词法环境是一种规范类型，基于 ECMAScript 代码的词法嵌套结构来定义标识符和具体变量和函数的关联。一个词法环境由环境记录器和一个可能的引用outer词法环境的空值组成。

简单来讲词法环境是一种持有标识符—变量映射的结构。（这里的标识符指的是变量/函数的名字，而变量是对实际对象[包含函数类型对象]或原始数据的引用）。

如今，在词法环境的内部有两个组件：(1) 环境记录器和 (2) 一个外部环境的引用。

环境记录器是存储变量和函数声明的实际位置。
外部环境的引用意味着它能够访问其父级词法环境（做用域）。

译者注：外部环境已经跟 ES3 规定的做用域的做用相似

词法环境有两种类型：

全局环境（在全局执行上下文中）是没有外部环境引用的词法环境。全局环境的外部环境引用是 null。它拥有内建的 Object/Array/等、在环境记录器内的原型函数（关联全局对象，好比 window 对象）还有任何用户定义的全局变量，而且 this的值指向全局对象。
在 函数环境中，函数内部用户定义的变量存储在 环境记录器中。而且引用的外部环境多是全局环境，或者任何包含此内部函数的外部函数。

环境记录器也有两种类型（如上！）：

声明式环境记录器存储变量、函数和参数。
对象环境记录器用来定义出如今 全局上下文中的变量和函数的关系。

简而言之，

在 全局环境中，环境记录器是对象环境记录器。
在 函数环境中，环境记录器是声明式环境记录器。

注意 — 对于函数环境，声明式环境记录器还包含了一个传递给函数的 arguments 对象（此对象存储索引和参数的映射）和传递给函数的参数的 length。

抽象地讲，词法环境在伪代码中看起来像这样：

GlobalExectionContext = {
  LexicalEnvironment: {
    EnvironmentRecord: {
      Type: "Object",
      // 在这里绑定标识符
    }
    outer: <null>
  }
}

FunctionExectionContext = {
  LexicalEnvironment: {
    EnvironmentRecord: {
      Type: "Declarative",
      // 在这里绑定标识符
    }
    outer: <Global or outer function environment reference>
  }
}

变量环境：

它一样是一个词法环境，其环境记录器持有变量声明语句在执行上下文中建立的绑定关系。

如上所述，变量环境也是一个词法环境，因此它有着上面定义的词法环境的全部属性。

在 ES6 中，词法环境组件和变量环境的一个不一样就是前者被用来存储函数声明和变量（let 和 const）绑定，然后者只用来存储 var 变量绑定。

咱们看点样例代码来理解上面的概念：

let a = 20;
const b = 30;
var c;

function multiply(e, f) {
 var g = 20;
 return e * f * g;
}

c = multiply(20, 30);

执行上下文看起来像这样：

GlobalExectionContext = {

  ThisBinding: <Global Object>,

  LexicalEnvironment: {
    EnvironmentRecord: {
      Type: "Object",
      // 在这里绑定标识符
      a: < uninitialized >,
      b: < uninitialized >,
      multiply: < func >
    }
    outer: <null>
  },

  VariableEnvironment: {
    EnvironmentRecord: {
      Type: "Object",
      // 在这里绑定标识符
      c: undefined,
    }
    outer: <null>
  }
}

FunctionExectionContext = {
  ThisBinding: <Global Object>,

  LexicalEnvironment: {
    EnvironmentRecord: {
      Type: "Declarative",
      // 在这里绑定标识符
      Arguments: {0: 20, 1: 30, length: 2},
    },
    outer: <GlobalLexicalEnvironment>
  },

VariableEnvironment: {
    EnvironmentRecord: {
      Type: "Declarative",
      // 在这里绑定标识符
      g: undefined
    },
    outer: <GlobalLexicalEnvironment>
  }
}

注意 — 只有遇到调用函数 multiply 时，函数执行上下文才会被建立。

可能你已经注意到 let 和 const 定义的变量并无关联任何值，但 var 定义的变量被设成了 undefined。

这是由于在建立阶段时，引擎检查代码找出变量和函数声明，虽然函数声明彻底存储在环境中，可是变量最初设置为 undefined（var 状况下），或者未初始化（let 和 const 状况下）。

这就是为何你能够在声明以前访问 var 定义的变量（虽然是 undefined），可是在声明以前访问 let 和 const 的变量会获得一个引用错误。

这就是咱们说的变量声明提高。

执行阶段

这是整篇文章中最简单的部分。在此阶段，完成对全部这些变量的分配，最后执行代码。

注意 — 在执行阶段，若是 JavaScript 引擎不能在源码中声明的实际位置找到 let 变量的值，它会被赋值为 undefined。

结论

咱们已经讨论过 JavaScript 程序内部是如何执行的。虽然要成为一名卓越的 JavaScript 开发者并不须要学会所有这些概念，可是若是对上面概念能有不错的理解将有助于你更轻松，更深刻地理解其余概念，如变量声明提高，做用域和闭包。

原文连接是：https://blog.bitsrc.io/understanding-execution-context-and-execution-stack-in-javascript-1c9ea8642dd0

参考资料

[1]

官方的 ES6: http://ecma-international.org/ecma-262/6.0/

交流讨论

欢迎关注公众号「前端试炼」，公众号平时会分享一些实用或者有意思的东西，发现代码之美。专一深度和最佳实践，但愿打造一个高质量的公众号。

公众号后台回复「加群」，拉你进交流面试群。

若是你不想加群，只是想加我也是能够的。

若是以为这篇文章还不错，来个【分享、点赞、在看】三连吧，让更多的人也看到~

本文分享自微信公众号 - 前端试炼（code-photo）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。