执行上下文

FlingPig
989 阅读5分钟

什么是执行期上下文？

它指的是：JS被解析和执行的时候所在的一个环境。（系统进行内部处理）

执行上下文的类型

1. 全局执行上下文：

有且只有一个，浏览器的全局对象就是window对象，this指向这个全局对象。

2.函数执行上下文：

存在无数个，只有在函数被调用的时候才会被创建，每次调用函数都会创建一个新的执行上下文。

执行栈

执行栈，也叫调用栈，具有 LIFO（后进先出）结构，用于存储在代码执行期间创建的所有执行上下文。

首次运行JS代码时，会创建一个全局执行上下文并按照栈的规则插到当前的执行栈中。每当发生函数调用，引擎都会为该函数创建一个新的函数执行上下文并插到当前执行栈的栈顶。

根据执行栈LIFO规则，当栈顶函数运行完成后，其对应的函数执行上下文将会从执行栈中移除，上下文控制权将移到当前执行栈的下一个执行上下文。

    var a = 'Hello World!';
    
    function first() {  
      console.log('Inside first function');  
      second();  
      console.log('Again inside first function');  
    }
    
    function second() {  
      console.log('Inside second function');  
    }
    
    first();  
    console.log('Inside Global Execution Context');
    
    // Inside first function
    // Inside second function
    // Again inside first function
    // Inside Global Execution Context

执行上下文的创建

执行上下文分两个阶段创建：

  1. 创建阶段；
  2. 执行阶段

创建阶段

  1. 确定 this 的值，也被称为 This Binding。

  2. LexicalEnvironment（词法环境） 组件被创建。

  3. VariableEnvironment（变量环境） 组件被创建。 This Binding 全局执行上下文中，this 的值指向全局对象，在浏览器中this 的值指向 window对象，而在nodejs中指向这个文件的module对象。

函数执行上下文中，this 的值取决于函数的调用方式。具体有：默认绑定、隐式绑定、显式绑定（硬绑定）、new绑定、箭头函数，具体内容会在【this全面解析】部分详解。

词法环境（Lexical Environment）

词法环境有两个组成部分:

1、环境记录：存储变量和函数声明的实际位置

2、对外部环境的引用：可以访问其外部词法环境

词法环境有两种类型:

1、全局环境：是一个没有外部环境的词法环境，其外部环境引用为 null。拥有一个全局对象（window 对象）及其关联的方法和属性（例如数组方法）以及任何用户自定义的全局变量，this 的值指向这个全局对象。

2、函数环境：在函数里面定义的变量会被存储在环境记录中，其中包含了arguments 对象。对外部环境的引用可以是全局环境，也可以是包含内部函数的外部函数环境。

    GlobalExectionContext = {  // 全局执行上下文
      LexicalEnvironment: {    	  // 词法环境
        EnvironmentRecord: {   		// 环境记录
          Type: "Object",      		   // 全局环境
          // 标识符绑定在这里 
          outer: <null>  	   		   // 对外部环境的引用
      }  
    }
    
    FunctionExectionContext = { // 函数执行上下文
      LexicalEnvironment: {  	  // 词法环境
        EnvironmentRecord: {  		// 环境记录
          Type: "Declarative",  	   // 函数环境
          // 标识符绑定在这里 			  // 对外部环境的引用
          outer: <Global or outer function environment reference>  
      }  
    }

变量环境

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

词法环境和变量环境的区别在于前者用于存储函数声明和变量（ 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>  
      }  
    }

执行过程

执行上下文的代码会分成两个阶段进行处理

1、进入执行上下文

2、代码执行

进入执行上下文

很明显，这个时候还没有执行代码

此时的变量对象会包括（如下顺序初始化）：

  1. 函数的所有形参 (only函数上下文)：没有实参，属性值设为undefined。

  2. 函数声明：如果变量对象已经存在相同名称的属性，则完全替换这个属性。

  3. 变量声明：如果变量名称跟已经声明的形参或函数相同，则变量声明不会干扰已经存在的这类属性。 例如：

     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
    }//此时argument已经赋值，但是变量依然是undefinde,只是初始化了值。

代码执行：

    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、在代码执行阶段，会再次修改变量对象的属性值

avatar
文章
阅读
粉丝