function a() {  b()}
function b() {  c()}
function c() {  console.log('c');}a()

ECStack = [    globalContext];

// 按照执行顺序，分别创建对应函数的执行上下文，并且压入执行上下文栈的栈顶ECStack.push(functionAContext)    // push aECStack.push(functionBContext)    // push bECStack.push(functionCContext)    // push c
// 栈执行，首先C函数执行完毕,先进后出，ECStack.pop()   // 弹出cECStack.pop()   // 弹出bECStack.pop()   // 弹出a
// javascript接着执行下面的代码，但是ECStack底层永远有个globalContext,直到整个应用程序结束的时候，ECStack 才会被清空// ......// ......

class Stack {  constructor(){    this.items = []  }  push(ele) {    this.items.push(ele)  }  pop() {    return this.items.pop()  }}
let stack = new Stack()stack.push(1)stack.push(2)stack.push(3)console.log(stack.pop())    // 3console.log(stack.pop())    // 2console.log(stack.pop())    // 1

// 词法作用域var value = 1;
function foo() {    console.log(value);}
function bar() {    var value = 2;    foo();}
bar();    // 1

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

ECStack.push(<checkscope> functionContext);ECStack.push(<f> functionContext);ECStack.pop();ECStack.pop();

ECStack.push(<checkscope> functionContext);ECStack.pop();ECStack.push(<f> functionContext);ECStack.pop();

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

foo.[[scope]] = [  globalContext.VO];
bar.[[scope]] = [    fooContext.AO,    globalContext.VO];

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

// 1.chec
kscope 函数被创建，保存父变量对象到 内部属性[[scope]] checkscope.[[scope]] = [    globalContext.VO];
// 2.执行 checkscope 函数，创建 checkscope 函数执行上下文，checkscope 函数执行上下文被压入执行上下文栈ECStack = [    checkscopeContext,    globalContext];
// 3.checkscope 函数并不立刻执行，开始做准备工作，第一步：复制函数[[scope]]属性创建作用域链checkscopeContext = {    Scope: checkscope.[[scope]],}
// 4.用 arguments 创建活动对象，随后初始化活动对象，加入形参、函数声明、变量声明checkscopeContext = {    AO: {        arguments: {            length: 0        },        scope2: undefined    }，    Scope: checkscope.[[scope]],}
// 5.将活动对象压入 checkscope 作用域链Scope的顶端checkscopeContext = {    AO: {        arguments: {            length: 0        },        scope2: undefined    },    Scope: [AO, [[Scope]]]}
// 6.准备工作做完，开始执行函数，随着函数的执行，修改 AO 的属性值checkscopeContext = {    AO: {        arguments: {            length: 0        },        scope2: 'local scope'    },    Scope: [AO, [[Scope]]]}
// 7.查找到 scope2 的值，返回后函数执行完毕，函数上下文从执行上下文栈中弹出ECStack = [    globalContext];

var scope = "global scope";function checkscope(){  var scope = "local scope";  function f(){      return scope;  }  return f();}checkscope();
// 1.执行全局代码，创建全局执行上下文，全局上下文被压入执行上下文栈  ECStack = [    globalContext  ];
// 2.全局上下文初始化  globalContext = {    VO: [global],    Scope: [globalContext.VO],    this: globalContext.VO  }
// 3.初始化的同时，checkscope 函数被创建，保存作用域链到函数的内部属性[[scope]]  checkscope.[[scope]] = [    globalContext.VO  ];
// 4.执行 checkscope 函数，创建 checkscope 函数执行上下文，并压入执行上下文栈  ECStack = [    checkscopeContext,    globalContext  ];
// 5.checkscope 函数执行上下文初始化：/** * 复制函数 [[scope]] 属性创建作用域链， * 用 arguments 创建活动对象， * 初始化活动对象，即加入形参、函数声明、变量声明， * 将活动对象压入 checkscope 作用域链顶端。 * 同时 f 函数被创建，保存作用域链到 f 函数的内部属性[[scope]] */  checkscopeContext = {    AO: {      arguments: {          length: 0      },      scope: undefined,      f: reference to function f(){}    // 引用函数    },    Scope: [AO, globalContext.VO],    this: undefined  }
// 6.执行 f 函数，创建 f 函数执行上下文，f 函数执行上下文被压入执行上下文栈  ECStack = [    fContext,    checkscopeContext,    globalContext  ];
// 7.f 函数执行上下文初始化, 以下跟第 5 步相同：  /**  复制函数 [[scope]] 属性创建作用域链  用 arguments 创建活动对象  初始化活动对象，即加入形参、函数声明、变量声明  将活动对象压入 f 作用域链顶端  */  fContext = {    AO: {      arguments: {          length: 0      }    },    Scope: [AO, checkscopeContext.AO, globalContext.VO],    this: undefined  }// 8.f 函数执行，沿着作用域链查找 scope 值，返回 scope 值
// 9.f 函数执行完毕，f 函数上下文从执行上下文栈中弹出  ECStack = [    checkscopeContext,    globalContext  ];
// 10.checkscope 函数执行完毕，checkscope 执行上下文从执行上下文栈中弹出  ECStack = [    globalContext  ];

ExecutionContext = {      ThisBinding = <this value>,  // 确定this    LexicalEnvironment = {},     // 创建词法环境    VariableEnvironment = {},    // 创建变量环境};

GlobalExectionContext = {    // 全局环境  LexicalEnvironment: {      // 全局词法环境    EnvironmentRecord: {     // 类型为对象环境记录      Type: "Object",       // 标识符绑定在这里     },    outer: < null >  }};
FunctionExectionContext = {   // 函数环境  LexicalEnvironment: {       // 函数词法环境    EnvironmentRecord: {      // 类型为声明性环境记录      Type: "Declarative",       // 标识符绑定在这里     },    outer: < Global or outerfunction environment reference >  }};

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,  // this绑定为全局对象    LexicalEnvironment: {          // 词法环境      EnvironmentRecord: {                 Type: "Object",            // 对象环境记录        // let const创建的变量a b在这        a:  uninitialized ,          b:  uninitialized ,          multiply: < func >        }      outer: null                // 全局环境外部环境引入为null    },
    VariableEnvironment: {         // 变量环境      EnvironmentRecord: {                 Type: "Object",            // 对象环境记录        // var创建的c在这        c: undefined,        }      outer: null                // 全局环境外部环境引入为null    }    }
// 函数执行上下文FunctionExectionContext = {  ThisBinding: Global Object, //由于函数是默认调用 this绑定同样是全局对象  LexicalEnvironment: {          // 词法环境    EnvironmentRecord: {               Type: "Declarative",       // 声明性环境记录      // arguments对象在这      Arguments: {0: 20, 1: 30, length: 2},      },      outer: GlobalEnvironment    // 外部环境引入记录为Global  },
  VariableEnvironment: {          // 变量环境    EnvironmentRecord: {                Type: "Declarative",        // 声明性环境记录      // var创建的g在这      g: undefined      },      outer: GlobalEnvironment    // 外部环境引入记录为Global  }  }

let scope = "global scope";function checkscope() {    let scope = "local scope";   // 自由变量    function f() {    // 闭包        console.log(scope);    };    return f;};
let foo = checkscope();foo();

// 1. 伪代码分别表示执行栈中上下文的变化，以及上下文创建的过程，首先执行栈中永远都会存在一个全局执行上下文。ECStack = [GlobalExecutionContext];
// 2. 此时全局上下文中存在两个变量scope、foo与一个函数checkscope，上下文用伪代码表示具体是这样：GlobalExecutionContext = {     // 全局执行上下文    ThisBinding: Global Object  ,    LexicalEnvironment: {      // 词法环境        EnvironmentRecord: {            Type: "Object",    // 对象环境记录            scope: uninitialized ,            foo: uninitialized ,            checkscope: func         }        outer: null   // 全局环境外部环境引入为null    }}// 3. 全局上下文创建阶段结束，进入执行阶段，全局执行上下文的标识符中像scope、foo之类的变量被赋值，然后开始执行checkscope函数，于是一个新的函数执行上下文被创建，并压入执行栈中：ECStack = [checkscopeExecutionContext,GlobalExecutionContext];
// 4. checkscope函数执行上下文进入创建阶段：checkscopeExecutionContext = {      // 函数执行上下文    ThisBinding: Global Object,    LexicalEnvironment: {           // 词法环境        EnvironmentRecord: {            Type: "Declarative",    // 声明性环境记录            Arguments: {},            scope: uninitialized ,            f: func         },        outer: GlobalLexicalEnvironment   // 外部环境引入记录为<Global>    }}
// 5. checkscope() 等同于window.checkscope() ，所以checkExectionContext 中this指向全局，而且外部环境引用outer也指向了全局(作用域链)，其次在标识符中记录了arguments对象以及变量scope与函数f// 6. 函数 checkscope 执行到返回函数 f 时，函数执行完毕，checkscope 的执行上下文被弹出执行栈，所以此时执行栈中又只剩下全局执行上下文：ECStack = [GlobalExecutionContext];
// 7. 代码foo()执行，创建foo的执行上下文，ECStack = [fooExecutionContext, GlobalExecutionContext];
// 8. foo的执行上下文是这样：fooExecutionContext = {    ThisBinding: Global Object ,    LexicalEnvironment: {             // 词法环境        EnvironmentRecord: {            Type: "Declarative",      // 声明性环境记录            Arguments: {},        },        outer: checkscopeEnvironment  // 外部环境引入记录为<checkscope>    }}// 9. foo()等同于window.foo()，所以this指向全局window，但outer外部环境引入有点不同，指向了外层函数 checkscope(原因是JS采用词法作用域，也就是静态作用域，函数的作用域在定义时就确定了，而不是执行时确定)/** * a. 但是可以发现的是，现在执行栈中只有 fooExecutionContext 和 GlobalExecutionContext, checkscopeExecutionContext 在执行完后就被释放了，怎么还能访问到 其中的变量？ * b. 正常来说确实是不可以，但是因为闭包 foo 外部环境 outer 的引用，从而让 checkscope作用域中的变量依旧存活在内存中，无法被释放，所以有时有必要手动释放自由变量。 * c. 总结一句，闭包是指能使用其它作用域自由变量的函数，即使作用域已销毁。 */

let fn = (function () {  var privateCounter = 0;
  function changeBy(val) {    privateCounter += val;  };  return {    increment: function () {        changeBy(1);    },    decrement: function () {        changeBy(-1);    },    value: function () {        console.log(privateCounter);    }  };})();fn.value();     // 0fn.increment();fn.increment();fn.value();     // 2fn.decrement();fn.value();     // 1

function Echo(name) {  var age = 26;       // 私有属性  this.name = name;   // 构造器属性  this.hello = function () {      console.log(`我的名字是${this.name},我今年${age}了`);  };};var person = new Echo('yya');person.hello();    //我的名字是yya,我今年26了

function makeAdder(x) {    return function (y) {        console.log(x + y);    };};
var add5 = makeAdder(5);var add10 = makeAdder(10);add5(2); // 7add10(2); // 12