精华内容
下载资源
问答
  • 2022-03-21 18:12:44


    前言

    本章说一下JavaScript的执行上下文和作用域


    一、执行上下文是什么?

    执行上下文是评估和执行JavaScript代码环境的抽象概念。

    1.执行上下文的种类

    执行上下文一共包含以下三种:

    • 全局执行上下文:任何不在函数内部的代码均在全局上下文中。
      注意: 一个程序里面有且仅有一个全局执行上下文。
    • 函数执行上下文:每当一个函数被调用时,都会为该函数创建一个函数上下文。
      注意: 函数上下文可以有任意多个。
    • Eval函数执行上下文:执行在eval函数内部的代码也会有属于自己的执行上下文。(由于此类函数在日常开发中很少见,我们只谈全局执行上下文和函数执行上下文)。

    2.执行栈

    执行栈: 是一种LIFO(后进先出)的数据结构栈,用来存储代码运行时创建的所有执行上下文。当JavaScript引擎第一次遇到脚本时,他会创建一个全局的执行上下文并压入当前的执行栈。每当引擎遇到一个函数的调用,他会为该函数创建一个执行上下文并压入执行栈的顶部。引擎会执行那些执行上下文位于栈顶的函数,当函数执行完成时,执行上下文从栈顶弹出,控制流程到达当前栈中的下一个执行上下文。

    3.创建执行上下文

    创建执行上下文分为两个阶段:创建阶段执行阶段
    创建阶段又分为三部分:

    1. this的绑定
    2. 创建词法环境组件
    3. 创建变量环境组件

    this的绑定: 在全局上下文中,this的值指向全局对象(在浏览器里面,this指向window对象);在函数执行上下文中,this的指向取决于函数是如何被调用的。如果函数被一个引用对象调用,那么this指向那个对象,否则this的值被设置为全局对象或是undefined(在严格模式下)

    词法环境: 是一种规范类型,基于ECMAScript代码的词法结构来定义标识符和具体变量以及函数的关联。一个词法环境由环境记录器和一个可能引用外部词法环境的空值组成。
    其中,环境记录器指的是:存储变量和函数声明的实际位置;外部环境的引用:意味着它可以访问其父级词法环境。

    词法环境分为两种:
    1.全局环境(在全局执行上下文中) 没有外部环境引用的词法环境。全局环境的外部引用是null。
    它拥有内建的 Object/Array/等、在环境记录器内的原型函数(关联全局对象,比如 window 对象)还有任何用户定义的全局变量,并且this的值指向全局对象。

    2.函数环境: 函数内部用户自定义的变量存储在环境记录器中。并且引用的外部环境可能是全局环境,或者任何包含此内部函数的外部函数。

    环境记录器分为两种:
    1.声明式环境记录器: 存储变量、函数以及参数
    2.对象环境记录器: 定义出现在全局上下文中的变量和函数的关系

    变量环境: 同样是一个词法环境,其环境记录器持有变量声明语句在执行上下文中创建的绑定关系。
    注意: 在ES6中,词法环境组件和变量环境组件的一个不同:词法环境组件被用来存储函数声明和变量(let和const)声明,而变量环境只用来存储var声明的变量

    执行阶段: 在此阶段,完成对所有这些变量的分配,最后执行代码

    执行上下文案例一:

    function first() {
    	console.log('第一行');
    	second();
    	console.log('第二行');
    }
    function second() {
    	console.log('第三行');
    }
    first();
    console.log('第四行');
    // 输出:
    	第一行
    	第三行
    	第二行
    	第四行
    

    解释: 首先JavaScript引擎创建一个全局执行上下文,将全局执行上下文压入栈顶,遇到first函数执行,将first函数压入栈顶,随后输出“第一行”,紧接着遇到second函数执行,将其压入栈顶,随后输出“第三行”,second函数从栈顶弹出,然后first函数继续执行,输出“第二行”,随后从栈顶弹出。紧接着,全局执行上下文里面的console输出“第四行”,随后执行完毕。JavaScript引擎将全局执行上下文弹出。

    执行上下文案例二:

    var scope = "global scope";
    function checkscope(){
        var scope = "local scope";
        function f(){
            return scope;
        }
        return f();
    }
    checkscope();
    // 输出 local scope
    

    解释:

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

    执行上下文案例三:

    var scope = "global scope";
    function checkscope(){
        var scope = "local scope";
        function f(){
            return scope;
        }
        return f;
    }
    checkscope()();
    // 输出 local scope
    
    ECStack.push(<checkscope> functionContext);
    ECStack.pop();
    ECStack.push(<f> functionContext);
    ECStack.pop();
    

    理解this的绑定案例一:

    let foo = {
    	baz: function () {
    		console.log(this);
    	}
    }
    foo.baz(); // 'this' 引用 'foo', 因为 'baz' 被对象 'foo' 调用
    let bar = foo.baz;
    bar(); // 'this' 指向全局 window 对象,因为没有指定引用对象
    

    二、作用域与作用域链

    1.作用域种类

    作用域决定了这些变量的可访问性(可见性)
    作用域分为:函数作用域、全局作用域、块级作用域
    作用域: 即变量(变量作用域又称上下文)和函数生效(能被访问)的区域或集合
    函数作用域: 每个函数创建一个新的作用域,在创建函数的时候,函数的作用域就已经确定了
    全局作用域: 整个script标签包含的区域
    块级作用域: 在大括号中使用let和const声明的变量存在于块级作用域中。在大括号之外不能访问这些变量
    函数内部定义的变量从函数外部是不可访问的(不可见的)

    注意: JavaScript里面的作用域均属于静态作用域或词法作用域:变量被创建时就确定好了,而非执行阶段确定的。也就是说我们写好代码时它的作用域就确定了

    2.作用域链

    变量对象: 与执行上下文相关的数据作用域,存储了在上下文中定义的变量和函数声明
    作用域链: 当查找变量的时候,会先从当前上下文的变量对象中查找,如果没有找到,就会从父级(词法层面上的父级)执行上下文的变量对象中查找,一直找到全局上下文的变量对象,也就是全局对象。这样由多个执行上下文的变量对象构成的链表就叫做作用域链

    作用域案例一:

    var a = 1;
    console.log(window.a); //1
    this.window.b = 2;
    console.log(this.b); //2
    

    解释: 浏览器JavaScript中,全局对象有window属性指向自身

    作用域案例二:

    function myFoo() {
    	console.log(a1);
    	a1 = 1;
    }
    myFoo();
    // 报错 Uncaught ReferenceError: a1 is not defined
    

    解释: a1未用let或const或var定义。

    作用域案例三:

    console.log(foo);// 打印函数
    function foo(){
    	console.log("foo");
    }
    var foo = 1;
    

    解释: 在进入执行上下文时,首先会处理函数声明,其次会处理变量声明

    作用域案例四:

    var sex = '男';
    function person() {
        var name = '张三';
        function student() {
            var age = 18;
            console.log(name); // 张三
            console.log(sex); // 男 
        }
        student();
        console.log(age); // Uncaught ReferenceError: age is not defined
    }
    person();
    

    解释:
    student函数内部属于最内层作用域,找不到name,向上一层作用域person函数内部找,找到了输出“张三”
    student内部输出cat时找不到,向上一层作用域person函数找,还找不到继续向上一层找,即全局作用域,找到了输出“男”
    在person函数内部输出age时找不到,向上一层作用域找,即全局作用域,还是找不到则报错

    更多相关内容
  • Javascript的执行环境和执行上下文的生命周期, 执行上下文和作用域的区别 变量对象和作用域

    执行上下文作用域链

    执行上下文(Execution Context):函数执行前进行的准备工作(也称执行上下文环境)

    运行 JavaScript 代码的时候,当代码执行进入一个环境时,就会为该环境创建一个执行上下文,它会在运行代码前做一些准备工作,如确定作用域,创建局部变量对象等。

    一:JavaScript执行环境

    <script>
            //全部变量
            function foo(){
                //局部上下文
                console.log("12");
            }
            foo();//12
            //eval函数:将字符串以js方式来运行
            //eval函数上下文
            eval("let a=1;console.log(a)");  //1
     </script>
    
    1.全局上下文
    • 全局执行上下文
    2.局部环境
    • 局部执行上下文
    3.eval函数环境
    • eval函数:将字符串以js方式来运行
    • eval函数执行上下文
    • 如果参数是表达式,则 eval() 计算表达式。如果参数是一个或多个 JavaScript 语句,则 eval() 执行这些语句。

    二:函数调用栈

    在 JavaScript 中,通过栈的存取方式来管理执行上下文,我们可称其为执行栈,或函数调用栈(Call Stack)。

    三:执行上下文生命周期

    • 执行上下文创建时会产生作用域链对象
    • 作用域链对象包含变量对象(vo)和scope对象
    • 其中Scope对象不是在执行上下文创建时产生,而是在函数声明时就产生了
    • Scope保存的是声明该函数所在的执行上下文的作用域链对象
    1.创建阶段
    • 创建变量
    • 初始化作用域链
    • 确定this指向
    • 确定作用域
    2.执行阶段
    • 变量对象赋值
    • 调用函数
    • 顺序执行其他代码

    四:执行上下文和作用域的区别

    前面有提到,执行全局代码时,会产生一个执行上下文环境,每次调用函数都又会执行上下文环境。当函数调用完成时,这个上下文环境以及其中的数据都会被消除(除了闭包),处于活动状态的执行上下文环境只有一个。

    而作用域在函数定义时就已经确定了,不是在函数调用时确定(区别于执行上下文环境,当然 this 也是上下文环境里的成分)

    作用域只是一个"地盘",其中没有变量。变量是通过作用域对应的执行上下文环境中的变量对象来实现的。所以作用域是静态观念的,而执行上下文环境是动态上的,两者并不一样。

    五:变量对象

    在函数的建立阶段,首先会建立 Arguments 对象。然后确定形式参数,检查当前上下文中的函数声明,每找到一个函数声明,就在 variableObject 下面用函数名建立一个属性,属性值就指向该函数在内存中的地址的一个引用。如果上述函数名已经存在于 variableObject(简称VO) 下面,那么对应的属性值会被新的引用给覆盖。最后,是确定当前上下文中的局部变量,如果遇到和函数名同名的变量,则会忽略该变量。

    六:作用域链

    所谓作用域链,就是内部上下文所有变量对象(包括父变量对象)的列表。此链主要是用于变量查询。

    scope:作用域链对象(声明对象的时候就开始产生scope了)

     var a=50;
            function foo1(){
                console.log(`foo1:${a}`);  //undefined
                var a = 100;
            }
            foo1();
            console.log(`全局:${a}`);  //50
            //当函数里面的var a = 100;改为a=100时,会输出(foo1:50,全局:100
    

    在这里插入图片描述

     var food="鸡翅";
            function eat(){
                console.log("吃",food);//吃鸡翅
            }
            (function(){
                var food = "包子";
                eat();   
            }())
    

    谁声明的函数就执行谁的作用域链

     var food = "鸡翅";
            (function () {
                var food = "包子";
                function eat() {
                    console.log("吃", food);//吃包子
                }
                eat();
            }())
    
      var a = 1;
            function b() {
                console.log(a);
                a = 10;  //a与函数名重名,把栈里面的存放一个地址的a改为10(a是一个函数)
                console.log(a);
                return;
                function a() {
    
                }
            }
            b();
            alert(a);  //1
    
     var f = true;
               if (f === true) {
                   var a = 10;
               }
               function fun() {
                   var b = 20;  //var在函数里面无法提升变量到函数外
                   c = 30;      //非严格模式下,如果作用域中没有所查询变量,全局作用域就会自动创建一个具有该名称的变量
               }
               fun();
               console.log(a);
               console.log(b);
               console.log(c);
    
    展开全文
  • 执行上下文和作用域的理解执行上下文执行上下文作用域作用域链 转自执行上下文和作用域的理解 参考深入理解javascript原型闭包(完结) 执行上下文 函数每调用一次,都会产生一个新的执行上下文环境。因为...

    对执行上下文和作用域的理解

    转自执行上下文和作用域的理解
    参考深入理解javascript原型和闭包(完结)

    执行上下文

    函数每调用一次,都会产生一个新的执行上下文环境。因为不同的调用可能就有不同的参数。

    function fn(x) {
      console.log(arguments)
      console.log(x)
    }
    fn(20)
    fn(10) // 不同的调用可能有不同的参数
    

    执行上下文栈

    执行全局代码时,会产生一个执行上下文环境,每次调用函数都又会执行上下文环境。当函数调用完成时,这个上下文环境以及其中的数据都会被消除(当然了闭包并不会乖乖就范),处于活动状态的执行上下文环境只有一个。

    // 这是一个压栈出栈的过程--执行上下文栈
    1 let a = 10, fn, // 1、进入全局上下文环境
    2    bar = function(x) {
    3      let b = 5
    4      fn(x + b) // 3、进入fn函数上下文环境
    5    }
    6 fn = function(y) {
    7  let c = 5
    8  console.log(y + c)
    9 }
    10
    11 bar(10) // 2、进入bar函数上下文环境
    

    (1)执行代码之前,首先创建全局上下文环境。(活动状态)

    // 全局上下文环境
    a: undefined
    fn: undefined
    bar: undefined
    this: window
    

    然后执行代码,代码到10行之前,上下文环境中的变量都在执行过程中被赋值。

    // 全局上下文环境
    a: 10
    fn: function
    bar: function
    this: window
    

    (2)然后执行到11行,调用bar函数。
    跳转到bar函数内部,执行函数体语句之前,会创建一个新的执行上下文环境。

    // bar执行上下文环境
    b: undefined
    x: 10
    arguments: [10]
    this: window
    

    然后将fn执行上下文环境压栈,设置为活动状态(当前唯一)

    (4)fn执行完毕后,调用fn函数生成的fn上下文环境出栈,被销毁。
    然后bar执行完毕后,调用bar函数生成的上下文环境出栈,被销毁。然后剩下全局上下文环境,出栈销毁。
    在这里插入图片描述

    作用域

    JS没有块级作用域,除了全局作用域,函数会创建自己的作用域。作用域在函数定义时就已经确定了,不是在函数调用确定(区别于执行上下文环境,当然this也是上下文环境里的成分)

    // 全局作用域
    let x = 100
        // fn作用域
        function fn(x) {
            // bar作用域
            function bar(x) {
              console.log(x)
            }
        }
    
    let f1 = fn(5)
    let f2 = fn(10)
    
    f1() // 5
    f2() // 10
    

    作用域只是一个“地盘”,其中没有变量。变量是通过作用域对应的执行上下文环境中的变量对象来实现的。所以作用域是静态观念的,而执行上下文环境是动态上的,两者并不一样。有闭包存在时,一个作用域存在两个上下文环境也是有的。

    同一个作用域下,对同一个函数的不同的调用会产生不同的执行上下文环境,继而产生不同的变量的值,所以,作用域中变量的值是在执行过程中确定的,而作用域是在函数创建时就确定的。

    如果要查找一个作用域下某个变量的值,就需要找到这个作用域对应的执行上下文环境,再在其中找到变量的值。

    作用域链

    函数在定义的时候(不是调用的时候)就已经确定了函数体内部自由变量的作用域。

    自由变量:比如a,是在fn作用域使用,但是并没有在fn作用域定义,这就是自由变量。

    let a = 100
    function fn() {
      let b = 20
      function bar() {
        console.log(a + b) // a是自由变量
      }
      return bar
    }
    
    let x = fn(), b = 200
    x()   
    

    那么自由变量是如何得到的呢?这就引出了作用域链。

    bar要取得a的值,就要到创建bar这个函数的作用域中取值(这里是fn作用域),fn作用域也没有a,就到创建fn这个函数的作用域中取值(这里是全局作用域),找到了就结束了。这就是作用域链。

    展开全文
  • 文章目录变量提升执行上下文全局执行上下文函数执行上下文执行上下文作用域例题举个栗子 执行上下文栈:举个栗子 变量提升+执行上下文栈:举个栗子 预处理顺序举个栗子 预处理举个栗子 顺序执行举个栗子 作用域举...
  • 只有理解了执行上下文作用域,才能更好地理解JavaScript语言本身 一、执行上下文 简单引入:执行上下文(也称上下文)是当前代码的执行环境。(建议阅读时自动将执行上下文理解成执行环境) 1.类型 全局...

    前言

            只有理解了执行上下文与作用域链,才能更好地理解JavaScript语言的执行机制,在开发中避免不必要的错误。


    一、执行上下文

            简单引入:执行上下文(也称上下文)是当前代码的执行环境。(建议阅读时自动将执行上下文理解成执行环境)。 

            变量或函数的上下文决定了他们可以访问哪些数据,以及他们的行为。

    1.类型

            全局执行上下文:最外围的执行环境,在浏览器情况下,在该环境的下执行的代码会执行以下步骤:(1)创建一个window对象;(2)将this指向这个window对象;通过var定义的全局变量和函数都会成为window对象的属性和方法。

            函数执行上下文:每个函数都有自己的上下文,当代码执行到该函数时,函数的上下文被推到一个上下文栈上。在函数执行完后,上下文栈会弹出该函数的上下文,将控制权返还给之前的执行上下文。

    2.生命周期

            每个执行上下文的生命周期都经历了:创建 -> 执行 -> 回收 三个阶段

    创建阶段:

    2.1.创建变量对象

            引入:每个上下文都有一个关联的变量对象,变量对象是与执行上下文相关的数据作用域用于存储在该执行上下文中的变量和函数声明。。

    全局执行上下文的变量对象:全局上下文的执行环境中,变量对象就是全局对象,在浏览器中是window对象

    函数执行上下文的变量对象:函数上下文执行环境中有该函数自身的变量对象,只存储了属于他自己的arguments对象,当函数进入执行阶段,其变量对象变成活动对象,此时函数上下文中声明的变量就可以被访问到,所以我们一般将活动对象称为函数执行上下文的变量对象

    举个栗子:

    // 全局上下文创建变量color
    var color = 'blue';
    // 全局上下文创建函数sayColor()
    function sayColor(a, b) {
        var c = 10;
        var d = function() {}
        function e() {}
    }
    console.log(window.color);    // blue
    console.log(window.sayColor);    // f sayColor() {}
    // 执行函数sayColor()
    sayColor(20.30);

    分析:

             由内:当函数sayColor()未进入执行阶段时,它上下文创建的变量对象大致如下:

    AO = {
        arguments: {
            0: 20,
            1: 30,
            length: 2
        }
        c: undefined,
        d: undefined,
        e: <function reference to e>
    }

    当函数sayColor()进入执行阶段时,其变量对象转变为活动对象,此时函数上下文创建的变量就可以被访问到,此时活动对象大致如下:

    AO = {
        arguments: {
            0: 20,
            1: 30,
            length: 2
        }
        c: 10,
        d: reference to Function expression to d,
        e: <function reference to e>
    }

            到外:当函数创建完自身的变量对象后,也就是它有了自身的数据作用域,我们将目光转向更外层的执行环境,可以发现函数sayColor()在全局上下文中执行,此时同理,全局上下文创建变量对象window,存储全局上下文的变量和函数声明,大致如下:

    window: {
        color: 'blue',
        sayColor: <function reference to sayColor>
        // ... 
        // ...
    }

    2.2.this绑定函数内部:this详解(重点)_JV_32的博客-CSDN博客

    • 全局执行上下文中,this值为全局对象(浏览器中,this值为window)
    • 函数执行上下文中,this值取决于该函数如何被调用的

    执行阶段:

    2.3.创建作用域链

    • 我们了解了变量对象后,代码在其上下文的执行环境的执行的过程中,会创建变量对象的一个作用域链,这个作用域链决定了各级上下文中的代码在访问变量和函数时的顺序。
    • 作用域链中的下一个变量对象来自包含该变量对象更外层的变量对象
    •  简单来说:沿着作用域链,内层代码可以访问外层声明变量与函数,外层无法访问内层声明的变量与函数

    举同一个栗子:

    // 全局上下文创建变量color
    var color = 'blue';
    // 全局上下文创建函数sayColor()
    function sayColor(a, b) {
        var c = 10;
        var d = function() {}
        function e() {}
    }
    console.log(window.color);    // blue
    console.log(window.sayColor);    // f sayColor() {}
    // 执行函数sayColor()
    sayColor(20.30);

    分析:此时各级上下文的变量对象关系如下:

    // 全局上下文的变量对象
    window: {
        color: 'blue',
        // 函数上下文的变量对象
        sayColor = {
            arguments: {
                0: 20,
                1: 30,
                length: 2
            },
            c: 10,
            d: reference to Function expression to d,
            e: <function reference to e>
        }
        // ... 
        // ...
    }

    举个栗子:

    var color = 'blue';
    function ChangeColor() {
        let anotherColor = 'red';
        function swapColor() {
            let tempColor = anotherColor;
            anotherColor = color;
            color = tempColor;
            // 这里可以访问到color、anotherColor、tempColor
        }
        // 这里可以访问到color、anotherColor,但无法访问tempColor
        swapColor();
    }
    
    // 这里只能访问color
    ChangeColor();

    分析:以上代码涉及三个上下文:全局上下文、changeColor()的局部上下文和swapColor()的局部上下文。内部上下文可以通过作用域链访问外部上下文中的一切,但外部上下文无法访问内部上下文中任何东西,此时各级上下文的变量对象关系如下:

    // 全局上下文变量对象
     window: {
        color: 'blue',
        // 局部函数上下文变量对象
        ChangeColor = {
            arguments: {
                length: 0
            },
            anotherColor: 'red',
            // 局部函数上下文变量对象的变量对象
            swapColor: {
                arguments: {
                    length: 0
                },
                tempColor: anotherColor
            }
        }
    }

    从变量对象分析:swapColor()的局部上下文首先从自己的变量对象开始搜索变量和函数,搜不到就去搜索上一级changeColor()变量对象的变量和函数,依次向上逐级搜索,因此可以在swapColor()中访问元素anotherColor和color。

    从作用域链分析:changeColor()上下文的作用域链中包含两个对象,它自己的变量对象和全局变量对象,因此它不能访问swapColor()的上下文;同理,swapColor()上下文的作用域链中包含三个对象,他自己的变量对象、changeColor()变量对象、全局变量对象,因此它可以访问changeColor()上下文以及全局上下文。


    总结

            本章节通过深入浅出了解了JavaScript执行上下文的概念并引入了作用域链,为JavaScript代码的执行机制有了一定的了解,为后续了解作用域、闭包等奠定了基础。。。

    展开全文
  • 全局执行上下文环境是在全局作用域确定之后,js代码马上执行之前创建的 函数执行上下文是在调用函数时,执行函数体代码之前创建 2. 区别2 作用域是静态的。只要函数定义好了就一直存在,且不会再变化 执行上...
  • JavaScript在执行代码之前,需要经过一系列的“准备”,这被称为执行上下文,其包含词法环境(Lexical Environment)上下文(this)。所有的 JavaScript 代码在运行时都是在执行上下文中进行的,每创建一个执行上...
  • 今天看完js执行上下文作用域感觉对js的执行上下文和作用域还是理解不够深刻,但是这个视频给我讲得明明白白了,在此记录下。 视频最后总结 Javascript变量先“登记”后使用,登记的地方叫执行上下文 var变量...
  • var scope = "global scope"; function checkscope(){ var scope = "local scope"; function f(){ return scope; } return f();... 函数作用域执行前就确定了,所以会从F1的作用域里找到变量a的值,为100
  • 作用域作用域链与执行上下文

    千次阅读 2021-03-11 11:22:41
    作用域、作用域链与执行上下文作用域一、作用域的作用二、作用域&执行上下文1.执行上下文2.作用域和执行上下文的区别三、作用域链1.查找变量的流程2.作用域链3.作用域链和执行上下文 作用域 作用域本身是一个...
  • (一)执行上下文 可以理解成,执行JavaScript代码的一种环境。(个人理解为任何事情的发生都是在一定环境下发生的,执行js代码也是一样,必然是在某种环境下进行。) 上下文分为以下3类: 1)全局执行上下文:指的...
  • JavaScript 采用词法作用域(lexical scoping),函数执行依赖的变量作用域是由函数定义的时候决定,而不是函数执行的时候决定,通过本文给大家介绍JavaScript作用域链、执行上下文与闭包相关知识,感兴趣的朋友一起...
  • 在这个系列文章里,我首先要说的是,闭包是和执行上下文作用域是有紧密的联系的,不能单独的去理解闭包,否则就容易走入死胡同。 这篇讲执行上下文。 一、什么是执行上下文 我们可以将执行上下文看作代码当前...
  • js作用域和执行上下文的区别

    千次阅读 多人点赞 2018-05-17 14:21:15
    前言之前,我以为作用域和执行上下文是同一个概念,其实并不是,这里很多人都会把它们混淆了。上下文 vs 作用域每个函数调用都有与之相关的作用域和上下文。从根本上说,范围是基于函数(function-based)而上下文是...
  • js中的执行上下文和作用域

    千次阅读 2017-12-06 10:36:36
    执行上下文又称词法环境,它是存储处理数据的栈,主要分为两部分: 预处理阶段: ①在这个阶段它会将所有的var类型的变量存入上下文中并给它赋值为undefined; ②除此之外,它还会将声明的函数存入栈中,并将...
  • 光是从字面上的概念上来理解的话有点绕,其实很好区分。var a=1; //全局作用域 function fn1(){ var a=2; //fn1作用域 }1234如上代码,作用域代表着已声明变量或者函数的访问范围... //全局执行上下文 function fn1(){
  • 执行上下文是一个抽象的概念,代表了代码执行的环境,包含:执行环境,变量对象,this,作用域链。 .流程: ——js引擎在js代码正式执行之前会创建一个执行环境 ——进入该环境以后创建一个变量对象,改对象用于收集...
  • 执行上下文(Execution context) 执行上下文(简称上下文)决定了Js执行过程中可以获取哪些变量、函数、数据,一段程序可能被分割成许多不同的上下文,每一个上下文都会绑定一个变量对象(variable object),它就像...
  • 主要介绍了Javascript中的作用域和上下文深入理解,本文讲解了作用域 VS 上下文、变量作用域、“this”上下文、执行上下文(Execution Context)、作用域链等内容,需要的朋友可以参考下
  • 全局执行上下文环境是在全局作用域确定后,js代码马上执行之前创建。 函数执行上下文是在调用函数时,函数体代码马上执行前创建。 区别2 作用域是静态的,只要函数定义好了就一直存在,并且不再发生变化。 执行上...
  •   作用域上下文执行上下文作用域链、闭包是JavaScript中关键概念之一,是JavaScript难点之一,在应聘面试时必定会问到的问题,作为前端工程师必须理解掌握。相信大家已经阅读了很多关于这方面的文章,...
  • 执行阶段由引擎完成, 主要任务是执行可执行代码,执行上下文在这个阶段创建。 作用域 作用域规定了如何查找变量/函数,也就是确定当前执行代码对变量/函数的访问权限,目的是为了提高程序的可靠性减少命名冲突。...
  • JavaScript的作用域(scope)和执行上下文(execution context)总是纠缠不清,以至于网上出现了大量文章来区分这两个概念。 MDN中是这样描述scope的: Scope The current context of execution. The context in ...
  • 不知道许多小伙伴是不是还是对作用域和执行上下文不清楚,这里就简单的给大家聊聊。 作用域 首先作用域指的是代码中特定变量的有效范围。 JavaScript采用的是静态作用域。代码写在哪里作用域就在哪里确定,而不是在...
  • 例如,在web浏览器中,全局执行环境被认为是windows对象,因此所有全局变量函数都是作为 window 对象的属性方法创建的,比如我们调用windows.load()方法。 某个执行环境中的所有代码执行完毕后,该环境被销毁,...
  • 执行上下文和作用域不同。执行上下文在运行时确定,随时可能改变,而作用域则在定义时确定,永远不会变。 3. 如果当前执行的是一个对象的方法,则执行上下文就是这个方法所附属的对象。 4. 如果当前是一个创建对象...
  • javascript中没有块级作用域,只有函数作用域和全局作用域。 什么是块级作用域?块级作用域就是定义在{}之内的范围,比如if(){}或者for(){}里那个{}里的范围就叫做块级作用域。如:if(){} if(0 ) { var name =...
  • 目录 ...五、作用域执行上下文 1.区别1 2.区别2 3.联系 六、作用域链 1.理解 2.查找一个变量的查找规则 一、变量提升与函数提升 1.变量声明提升 通过var定义(声明)的变量,在定...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 123,146
精华内容 49,258
关键字:

执行上下文和作用域

友情链接: Project.rar