<legend id='wl96X'><style id='wl96X'><dir id='wl96X'><q id='wl96X'></q></dir></style></legend>
      <bdo id='wl96X'></bdo><ul id='wl96X'></ul>

      <tfoot id='wl96X'></tfoot>

      <i id='wl96X'><tr id='wl96X'><dt id='wl96X'><q id='wl96X'><span id='wl96X'><b id='wl96X'><form id='wl96X'><ins id='wl96X'></ins><ul id='wl96X'></ul><sub id='wl96X'></sub></form><legend id='wl96X'></legend><bdo id='wl96X'><pre id='wl96X'><center id='wl96X'></center></pre></bdo></b><th id='wl96X'></th></span></q></dt></tr></i><div id='wl96X'><tfoot id='wl96X'></tfoot><dl id='wl96X'><fieldset id='wl96X'></fieldset></dl></div>

        <small id='wl96X'></small><noframes id='wl96X'>

      1. 通过实例了解JS执行上下文运行原理

        时间:2023-12-08
        • <bdo id='R6aMO'></bdo><ul id='R6aMO'></ul>

              <legend id='R6aMO'><style id='R6aMO'><dir id='R6aMO'><q id='R6aMO'></q></dir></style></legend>

                    <tbody id='R6aMO'></tbody>
                  <i id='R6aMO'><tr id='R6aMO'><dt id='R6aMO'><q id='R6aMO'><span id='R6aMO'><b id='R6aMO'><form id='R6aMO'><ins id='R6aMO'></ins><ul id='R6aMO'></ul><sub id='R6aMO'></sub></form><legend id='R6aMO'></legend><bdo id='R6aMO'><pre id='R6aMO'><center id='R6aMO'></center></pre></bdo></b><th id='R6aMO'></th></span></q></dt></tr></i><div id='R6aMO'><tfoot id='R6aMO'></tfoot><dl id='R6aMO'><fieldset id='R6aMO'></fieldset></dl></div>

                1. <small id='R6aMO'></small><noframes id='R6aMO'>

                2. <tfoot id='R6aMO'></tfoot>

                  JS执行上下文(execution context)是JS解释器在处理JS代码时,创建的一个对象,用来管理和维护当前代码的执行环境,包括当前作用域内的变量、函数声明、this指向和外部环境等相关信息。本文将通过两条实例,来深入了解JS执行上下文的运行原理。

                  执行上下文的创建过程

                  在JS解释器执行JS代码之前,首先会创建一个全局上下文(Global Execution Context),作为根上下文来管理整个JS代码运行期间的执行环境。在执行过程中,如果发现某段JS代码需要开启新的执行上下文,那么JS解释器会根据以下两个步骤,来创建新的执行上下文对象:

                  1. 创建阶段

                  创建新的执行上下文对象时,JS解释器会先为其创建一个空白的执行上下文对象(Execution Context Object)。执行上下文对象通常是一个包含三个属性的对象,分别是变量对象(Variable Object)、作用域链(Scope Chain)和this指向(This Value)。

                  1. 执行阶段

                  创建完成后,JS解释器会解析执行当前上下文中的JS代码,将代码、变量和函数声明等信息,加入到对应的执行上下文中。在此过程中,JS解释器会按照以下步骤进行:

                  • 识别变量声明和函数声明:JS解释器会先分析当前上下文中的JS代码,将所有的变量和函数声明保存在当前执行上下文的变量对象中。
                  • 建立作用域链:当JS解释器在当前上下文中访问变量或函数时,它会先在当前上下文的变量对象中查找,找不到时,会沿着作用域链依次查找外部环境的变量对象,直到找到为止。
                  • 确定this指向:JS解释器在执行上下文中,会识别当前上下文中的this指向,它会根据JS执行环境对this的定义,来确定this指向到哪里。

                  示例一

                  考虑以下JS代码:

                  var a = "Hello";
                  
                  (function() {
                    var b = "JavaScript";
                  
                    function inner() {
                      console.log(a + " " + b);
                    }
                  
                    inner();
                  })();
                  

                  在执行此代码时,JS解释器会按照如下过程:

                  1. 创建全局上下文(Global Execution Context)。
                  2. 解析到第一行代码,创建变量a并赋值"Hello",保存在全局上下文的变量对象中。
                  3. 程序运行到第3行代码,进入一个新的执行上下文函数(anonymous),JS解释器会创建一个新的执行上下文对象(Execution Context Object)。
                  4. (anonymous)的执行上下文中,JS解释器先创建变量b,并将其保存在执行上下文的变量对象中。同时,JS解释器还会将inner函数声明创建并保存在执行上下文的变量对象中。接着,JS解释器会根据作用域链原理,将全局上下文(Global Execution Context)的变量对象添加到当前上下文的作用域链中。
                  5. 执行inner函数时,JS解释器会进入inner函数的执行上下文。在此执行上下文中,JS解释器会先在当前执行上下文的变量对象中查找变量ab,找不到时,会沿着作用域链依次查找外部环境的变量对象,直到找到为止。
                  6. 执行完inner函数后,JS解释器跳回(anonymous)的执行上下文中,当代码执行完毕后,当前执行上下文被销毁。
                  7. 最后,全局上下文(Global Execution Context)随着程序的结束而销毁,JS代码运行结束。

                  示例二

                  考虑以下JS代码:

                  var a = "Global a";
                  var b = "Global b";
                  
                  function outer() {
                    var a = "Outer a";
                  
                    function inner() {
                      var b = "Inner b";
                      console.log(a + " " + b);
                    }
                  
                    inner();
                  }
                  
                  outer();
                  console.log(a + " " + b);
                  

                  在执行此代码时,JS解释器会按照如下过程:

                  1. 创建全局上下文(Global Execution Context)。
                  2. 解析到第一行代码,创建变量a并赋值"Global a",创建变量b并赋值"Global b",保存在全局上下文的变量对象中。
                  3. 程序运行到第6行代码,进入outer函数的执行上下文。在此执行上下文中,JS解释器会先创建变量a,并将其保存在执行上下文的变量对象中。同时,JS解释器还会将inner函数声明创建并保存在执行上下文的变量对象中。接着,JS解释器会根据作用域链原理,将全局上下文(Global Execution Context)的变量对象添加到当前上下文的作用域链中。
                  4. 执行inner函数时,JS解释器会进入inner函数的执行上下文。在此执行上下文中,JS解释器会先创建变量b,并将其保存在执行上下文的变量对象中。此时,执行上下文的作用域链为:inner执行上下文对象变量对象 -> outer执行上下文对象变量对象 -> 全局上下文对象变量对象。因此,变量a会沿着作用域链向外查找,从而找到outer函数中的a变量。而变量b则直接从当前执行上下文的变量对象中获取。
                  5. 执行完inner函数后,JS解释器跳回outer函数的执行上下文中,当函数执行完毕后,当前执行上下文被销毁。
                  6. 执行到最后一行代码时,JS解释器会在全局上下文中查找变量ab,并输出结果。
                  7. 最后,全局上下文(Global Execution Context)随着程序的结束而销毁,JS代码运行结束。

                  通过以上两个示例,我们可以清晰地了解JS执行上下文的创建和运行原理,这对理解JS代码的运行机制,有着非常重要的意义。

                  上一篇:JavaScript淡入淡出渐变简单实例 下一篇:JS 函数的 call、apply 及 bind 超详细方法

                  相关文章

                    <bdo id='kiE3I'></bdo><ul id='kiE3I'></ul>
                3. <legend id='kiE3I'><style id='kiE3I'><dir id='kiE3I'><q id='kiE3I'></q></dir></style></legend>

                    <tfoot id='kiE3I'></tfoot>
                    <i id='kiE3I'><tr id='kiE3I'><dt id='kiE3I'><q id='kiE3I'><span id='kiE3I'><b id='kiE3I'><form id='kiE3I'><ins id='kiE3I'></ins><ul id='kiE3I'></ul><sub id='kiE3I'></sub></form><legend id='kiE3I'></legend><bdo id='kiE3I'><pre id='kiE3I'><center id='kiE3I'></center></pre></bdo></b><th id='kiE3I'></th></span></q></dt></tr></i><div id='kiE3I'><tfoot id='kiE3I'></tfoot><dl id='kiE3I'><fieldset id='kiE3I'></fieldset></dl></div>

                      <small id='kiE3I'></small><noframes id='kiE3I'>