精华内容
下载资源
问答
  • 词法作用域、块作用域(已完结)

    千次阅读 2018-06-24 21:25:17
    换句话说,词法作用域是由你在写代码时将变量和块作用域写在哪里来决定的 由上面对词法作用域的描述可知,词法作用域的创建发生在预编译阶段,因为词法阶段属于预编译的一个过程 如果还是感觉不太理解,请考虑下面...

    词法作用域

    什么是词法作用域

    作用域共有两种主要的工作模型——词法作用域和动态作用域,JS采用词法作用域

    简单地说,词法作用域就是定义在词法阶段的作用域。换句话说,词法作用域是由你在写代码时将变量和块作用域写在哪里来决定的

    由上面对词法作用域的描述可知,词法作用域的创建发生在预编译阶段,因为词法阶段属于预编译的一个过程

    如果还是感觉不太理解,请考虑下面代码:

        function foo(a) {
            var b = a * 2;
            function bar(c) {
                console.log( a, b, c );
            }
            bar( b * 3 );
        }
        foo( 2 ); // 2, 4, 12

    在这个例子中有三个逐层嵌套的词法作用域(在此我们称之为气泡),看下图:
    嵌套的词法作用域

    1包含着整个全局作用域,其中只有一个标识符:foo

    2包含着foo 所创建的作用域,其中有三个标识符:a、bar 和b

    3包含着bar 所创建的作用域,其中只有一个标识符:c

    LHS与RHS的逐层查找便是逐层查找词法作用域,由内到外,由近到远。从外向内访问作用域是禁止的

    无论函数在哪里被调用,也无论它如何被调用,它的词法作用域都只由函数被声明时所处的位置决定

        function foo(){
            var a = 200;
            bar();
        }
        function bar(){
            console.log(a);//100
        }
        var a = 100;
        foo();

    虽然函数bar在foo中被调用,但是bar是定义在全局的,也就是说,bar的词法作用域嵌套关系为(由内到外):bar本身的词法作用域–>全局作用域。所以foo中的a并不影响输出结果

    词法作用域怎么形成

    你可以简单的认为词法作用域就是函数作用域(即上面图片中展示的相互嵌套的气泡)。但是这是片面的,因为,词法作用域由书写位置决定,那么,我在全局范围上声明一个变量,那么这个变量的词法作用域便是全局。

    其实我想说的是不要简单的将词法作用域理解为函数作用域(即上图嵌套的气泡)。词法作用域是针对所有标识符而言的,根据书写位置,预编译阶段便会将对应的标识符放在对应的词法作用域中,然后就形成了词法作用域

    所有由函数包裹的代码,都会在这个函数中形成词法作用域。就是上面图片展示的那样

        var a = 100;
        (function(){//会形成词法作用域,里面有a、b变量
            var a = 200;
            var b = 300;
            console.log(a);//200
        }());
        console.log(a);/*100,可见立即执行函数中给a赋值的操作并不影响全局a,这更说明了上述观点*/
        console.log(b);//访问不到立即执行函数中的b,此处报错
        function test(){
                var a = 100;
                setTimeout(function(){//该匿名函数同样形成词法作用域
                    var a = 200;
                    console.log(a);//200
                }, 2000);
                console.log(a);//100
        }
        test();
        //上述代码虽然存在闭包,但是这儿并没讨论闭包

    词法作用域包含了什么

    词法作用域中存放着代表变量或函数的标识符,以便进行函数与变量的LHS或RHS查询

    查找标识符

    在上一个代码片段中,引擎执行console.log(..) 声明,并查找a、b 和c 三个变量的引用。它首先从最内部的作用域,也就是bar(..) 函数的作用域气泡开始查找。引擎无法在这里找到a,因此会去上一级到所嵌套的foo(..) 的作用域中继续查找。在这里找到了a,因此引擎使用了这个引用。对b 来讲也是一样的。而对c 来说,引擎在bar(..) 中就找到了它

    遮蔽效应

    作用域查找会在找到第一个匹配的标识符时停止。在多层的嵌套作用域中可以定义同名的标识符,这叫作“遮蔽效应”(内部的标识符“遮蔽”了外部的标识符)。抛开遮蔽效应,作用域查找始终从运行时所处的最内部作用域开始,逐级向外或者说向上进行,直到遇见第一个匹配的标识符为止。

    考虑下面代码:

        var a = 10;
        function test(){
            var a = 100;
            console.log(a);//遮蔽效应,输出100
        }
        test();

    全局变量会自动成为全局对象(比如浏览器中的window 对象)的属性,因此可以不直接通过全局对象的词法名称,而是间接地通过对全局对象属性的引用来对其进行访问。window.a通过这种技术可以访问那些被同名变量所遮蔽的全局变量。

    词法作用域查找只会查找一级标识符,比如a、b 和c。如果代码中引用了foo.bar.baz,词法作用域查找只会试图查找foo 标识符,找到这个变量后,对象属性访问规则会分别接管对bar 和baz 属性的访问(在‘LHS与RHS查询’中已经提到过)

    块作用域

    或许我们经常说——JS中没有块级作用域。这并没有错,但是如果更加深入的说,JS中是存在块级作用域的,只是并不明显或直接

    with形式的块作用域

    具体请看前面的文案——‘eval与with’

    try/catch形式的块作用域

    ES3 规范中规定try/catch 的catch 分句会创建一个块作用域。但是这儿有一个值的注意的地方,请看代码:

        try{
            var b = 100;
            undefined();
        }catch(error){
            var a = 200;
            function test(){
                console.log('name');
            }
        }
        console.log(b);//100
        console.log(a);//200
        test();//test
        console.log(error);//报错

    catch不是生成了块级作用域吗?为什么a能在外部访问?

    因为catch生成的块作用域仅对形参(这儿是error)有效,注意这点

    let形式的块作用域

    ES6引入了let关键字,提供了除var以外的另一种变量声明方式。

    用let声明的变量会被绑定到let所在的块中(通常是{ .. } 内部)

        if(true){
            var aa = 100;
            let bb = 200;
        }
        console.log(aa);//100
        console.log(bb);//报错
        for(let i = 0; i < 3; i++){...}
        //这儿的i也会被绑定到后面的{}中

    用let声明的变量在预编译阶段不会进行变量提升

        {
            console.log(a);
            let a = 100;    
        }

    const形式的作用域

    const——单词译为‘常量’

    ES6 还引入了const,同样可以用来创建块作用域变量,但其值是固定的(常量)。之后任何试图修改值的操作都会引起错误

        var foo = true;
        if (foo) {
            var a = 2;
            const b = 3; // 包含在if 中的块作用域常量
            a = 3; // 正常!
            b = 4; // 错误!
        }
        console.log( a ); // 3
        console.log( b ); // 报错

    ps:本文参考并引用下列书籍
    《你不知道的JavaScript》(上卷)

    展开全文
  • 函数作用域和块作用域 函数作用域 函数作用域:属于这个函数的全部变量都可以在整个函数的范围的范围内使用及复用。 最小暴露原则:最小限度地暴露必要内容,而将其他内容隐藏起来,例如某个模块或对象的API...

    函数作用域和块作用域

    函数作用域

    函数作用域:属于这个函数的全部变量都可以在整个函数的范围的范围内使用及复用。

    最小暴露原则:最小限度地暴露必要内容,而将其他内容隐藏起来,例如某个模块或对象的API。

    在任意代码片段外部包装函数,可以隐藏内部的变量和函数定义,外部作用域无法访问。但是导致一些问题:1.必须声明一个具名函数foo( ),foo这个名称本身‘污染’了所在的作用域;2.必须显式地通过这个函数名(foo())调用这个函数才能运行其中的代码。

    问题:1.函数名污染所在作用域;2.自动运行不需要调用

    var a = 2;
    (function foo(){
        var a = 3;
        console.log(a);//3
    })();
    console.log(a);//2

    以上面的例子分析。

    1. 函数的声明以(function开始,而不是function,函数会被当成函数表达来处理,而不是标准的函数声明。
    2. 函数声明和函数表达式之间最重要的区别是:它们的名称标识符将会绑定在何处。(如果function是声明中的第一次词,那就是一个函数声明,否则就是一个函数表达式)
    3. 在上面的例子中,foo 被绑定在函数表达式自身的函数中而不是所在的作用域中。
    4. (function foo(){ … })作为函数表达式意味着foo只能在 … 所代表的位置中访问,外部作用域则不行。foo变量隐藏在自身中,不会污染外部作用域。

    匿名和具名函数表达式

    setTimeout(function(){
        console.log('123');
    },1000);

    该函数表达式为匿名函数表达式,因为没有名称标识符。

    (函数表达式可以是匿名的,而函数声明则不可以省略函数名)

    缺点:

    1. 匿名函数在栈追踪中不会显示有意义的函数名,使得调试很困难.
    2. 没有函数名,函数需要引用自身的时候只能使用已经过期的arguments.callee引用,例如递归。
    3. 匿名函数降低了函数可读性。

    立即执行函数表达式

    var a = 2;
    (function foo(){
        var a = 3;
        console.log(a);//3
    })();
    console.log(a);//2

    还是在上面这个例子中:对foo函数处理。

    第一个( )将函数变成表达式,第二个( )执行了这个函数。

    IIFE:立即执行函数。常见用法是使用一个匿名函数表达式。函数名对于IIFE来说非必须。

    另一种形式:(function( ){ … }( ))。两种形式功能完全一致。

    IFFE的另一个用法:当做函数调用并传递参数进去。

    var a = 2;
    (function IIFE(global){
        var a = 3;
        console.log(a);//3
        console.log(global.a);//2
    })(window);
    console.log(a);//2

    将window对象的引用传递进去,将参数命名为global。传入的可以是外部作用域的任何东西,此时外部作用域就是window,所有传window和this的效果是一样的。

    块作用域

    函数作用域是是最常见的作用域单元。

    for(var i=0; i<10; i++){
        console.log(i);
    }

    上面是一个经典的例子,在for循环的头部直接定义了变量i,通常是因为只想在for循环内部的上下文中使用i,但是会忽略掉i会被绑定在外部作用域中

    变量的声明应该距离使用的地方越近越好,并且最大限度地本地化。

    var foo = true;
    if(foo){
        var bar = foo * 2;
        bar = something(bar);
        console.log(bar);
    }

    上面的例子中,bar变量的声明仅在if声明的上下文使用,但是,使用var声明变量时,写在哪里都是一样的,它最终还是属于外部作用域。这个只是形式上的块作用域。

    let

    let关键字可以将变量绑定到所在的任意作用域中(通常是{…}内部)。换句话说,let为其声明的变量隐式地劫持了所在的块作用域。

    for(let i=0; i<10; i++){
        console.log(i);
    }

    for循环头部的let不仅将i绑定到了for循环的块中,事实上它将其重新绑定到了循环的每一个迭代中,确保上一个循环迭代结束时的值重新进行赋值。

    提升

    变量和函数在内的所有声明都会在任何代码被执行之前首先被处理。

    只有声明本身会被提升,而赋值或其它运行逻辑会留在原地。

    foo();
    function foo(){
        console.log(a)//undefined
        var a = 2;
    }

    上面的例子中,foo函数的声明被提升了。

    每个作用域都会有提升操作。foo函数内部的变量a也被提升。

    foo();//TypeError
    var foo = function(){
        //...
    }

    函数表达式不会被提升。

    函数优先

    函数声明和变量都会被提升,但是函数会首先被提升,然后才是变量。

    foo();//1
    var foo;
    function foo(){
        console.log(1);
    }
    foo = function(){
        console.log(2);
    }

    一个普通块内部的函数声明通常会被提升到所在作用域的顶部。

    foo();//b
    var a = true;
    if(a){
        function foo(){console.log('a');}
    } else {
        function foo(){console.log('b');}
    }

    上面例子中foo函数的两个声明都被提升到当前作用域顶部,else中的覆盖了if中的foo函数声明。

    展开全文
  • JavaScript笔记:函数作用域和块作用域

    1、函数中的作用域

    考虑如下的代码:

    function foo(a) { 
        var b = 2;
        // 一些代码
        function bar() { 
            // ...
        }
        // 更多的代码 
        var c = 3;
    }

    在这个代码片段中,foo(..) 的作用域中包含了标识符 a、b、c 和 bar。

    bar(..) 拥有自己的作用域。全局作用域也有自己的作用域气泡,它只包含了一个标识符:foo。

    由于标识符 a、b、c 和 bar 都附属于 foo(..) 的作用域,因此无法从 foo(..) 的外部 对它们进行访问。也就是说,这些标识符全都无法从全局作用域中进行访问,因此下面的代码会导致 ReferenceError 错误:

    bar(); // 失败
    console.log( a, b, c ); // 三个全都失败

    函数作用域的含义是指,属于这个函数的全部变量都可以在整个函数的范围内使用及复用(事实上在嵌套的作用域中也可以使用)。这种设计方案是非常有用的,能充分利用 JavaScript 变量可以根据需要改变值类型的“动态”特性。

    但与此同时,如果不细心处理那些可以在整个作用域范围内被访问的变量,可能会带来意想不到的问题。

    2、隐藏内部实现

    对函数的传统认知就是先声明一个函数,然后再向里面添加代码。但反过来想也可以带来一些启示:从所写的代码中挑选出一个任意的片段,然后用函数声明对它进行包装,实际上就是把这些代码“隐藏”起来了。

    实际的结果就是在这个代码片段的周围创建了一个作用域气泡,也就是说这段代码中的任何声明(变量或函数)都将绑定在这个新创建的包装函数的作用域中,而不是先前所在的作用域中。换句话说,可以把变量和函数包裹在一个函数的作用域中,然后用这个作用域来“隐藏”它们。

    为什么“隐藏”变量和函数是一个有用的技术?

    有很多原因促成了这种基于作用域的隐藏方法。它们大都是从最小特权原则中引申出来的,也叫最小授权或最小暴露原则。

    这个原则是指在软件设计中,应该最小限度地暴露必要内容,而将其他内容都“隐藏”起来,比如某个模块或对象的 API 设计。

    这个原则可以延伸到如何选择作用域来包含变量和函数。如果所有变量和函数都在全局作用域中,当然可以在所有的内部嵌套作用域中访问到它们。但这样会破坏前面提到的最小特权原则,因为可能会暴漏过多的变量或函数,而这些变量或函数本应该是私有的,正确的代码应该是可以阻止对这些变量或函数进行访问的。

    function doSomething(a) {
        b = a + doSomethingElse( a * 2 );
        console.log( b * 3 );
    }
    function doSomethingElse(a) { 
        return a - 1;
    }
    var b;
    doSomething( 2 ); // 15

    在这个代码片段中,变量 b 和函数 doSomethingElse(..) 应该是 doSomething(..) 内部具体实现的“私有”内容。给予外部作用域对 b 和 doSomethingElse(..) 的“访问权限”不仅没有必要,而且可能是“危险”的,因为它们可能被有意或无意地以非预期的方式使用, 从而导致超出了 doSomething(..) 的适用条件。更“合理”的设计会将这些私有的具体内容隐藏在 doSomething(..) 内部:

    function doSomething(a) { 
        function doSomethingElse(a) {
            return a - 1; 
        }
        var b;
        b = a + doSomethingElse( a * 2 );
        console.log( b * 3 );
    }
    doSomething( 2 ); // 15

    现在,b 和 doSomethingElse(..) 都无法从外部被访问,而只能被 doSomething(..) 所控制。功能性和最终效果都没有受影响,但是设计上将具体内容私有化了,设计良好的软件都会 依此进行实现。

    规避冲突:

    “隐藏”作用域中的变量和函数所带来的另一个好处,是可以避免同名标识符之间的冲突, 两个标识符可能具有相同的名字但用途却不一样,无意间可能造成命名冲突。冲突会导致变量的值被意外覆盖。

    1、全局命名空间

    变量冲突的一个典型例子存在于全局作用域中。当程序中加载了多个第三方库时,如果它们没有妥善地将内部私有的函数或变量隐藏起来,就会很容易引发冲突。

    这些库通常会在全局作用域中声明一个名字足够独特的变量,通常是一个对象。这个对象被用作库的命名空间,所有需要暴露给外界的功能都会成为这个对象(命名空间)的属性,而不是将自己的标识符暴漏在顶级的词法作用域中。

    2、模块管理

    另外一种避免冲突的办法和现代的模块机制很接近,就是从众多模块管理器中挑选一个来使用。使用这些工具,任何库都无需将标识符加入到全局作用域中,而是通过依赖管理器 的机制将库的标识符显式地导入到另外一个特定的作用域中。

    显而易见,这些工具并没有能够违反词法作用域规则的“神奇”功能。它们只是利用作用域的规则强制所有标识符都不能注入到共享作用域中,而是保持在私有、无冲突的作用域中,这样可以有效规避掉所有的意外冲突。

    3、函数作用域

    在任意代码片段外部添加包装函数,可以将内部的变量和函数定义“隐藏”起来,外部作用域无法访问包装函数内部的任何内容。

    var a = 2;
    function foo() { 
        var a = 3; 
        console.log( a ); // 3
    } 
    foo();
    console.log( a ); // 2

    虽然这种技术可以解决一些问题,但是它并不理想,因为会导致一些额外的问题。

    首先,必须声明一个具名函数 foo(),意味着 foo 这个名称本身“污染”了所在作用域(在这个例子中是全局作用域)。
    其次,必须显式地通过函数名(foo())调用这个函数才能运行其中的代码。

    如果函数不需要函数名(或者至少函数名可以不污染所在作用域),并且能够自动运行,这将会更加理想。

    JavaScript 提供了能够同时解决这两个问题的方案。

    (function foo(){ 
        var a = 3;
        console.log( a ); // 3 
    })();

    首先,包装函数的声明以 (function… 而不仅是以 function… 开始。尽管看上去这并不是一个很显眼的细节,但实际上却是非常重要的区别。函数会被当作函数表达式而不是一个标准的函数声明来处理。

    区分函数声明和表达式最简单的方法是看 function 关键字出现在声明中的位置(不仅仅是一行代码,而是整个声明中的位置)。如果 function 是声明中 的第一个词,那么就是一个函数声明,否则就是一个函数表达式。

    函数声明和函数表达式之间最重要的区别是它们的名称标识符将会绑定在何处。 比较一下前面两个代码片段。第一个片段中 foo 被绑定在所在作用域中,可以直接通过 foo() 来调用它。第二个片段中 foo 被绑定在函数表达式自身的函数中而不是所在作用域中。

    匿名和具名

    对于函数表达式你最熟悉的场景可能就是回调参数了,比如:

     setTimeout( function() {
        console.log("I waited 1 second!");
    }, 1000 );

    这叫作匿名函数表达式,因为 function().. 没有名称标识符。函数表达式可以是匿名的,而函数声明则不可以省略函数名——在 JavaScript 的语法中这是非法的。

    匿名函数表达式书写起来简单快捷,很多库和工具也倾向鼓励使用这种风格的代码。但是它也有几个缺点需要考虑。

    1. 匿名函数在栈追踪中不会显示出有意义的函数名,使得调试很困难。
    2. 如果没有函数名,当函数需要引用自身时只能使用已经过期的arguments.callee引用, 比如在递归中。另一个函数需要引用自身的例子,是在事件触发后事件监听器需要解绑自身。
    3. 匿名函数省略了对于代码可读性/可理解性很重要的函数名。一个描述性的名称可以让代码不言自明。

    行内函数表达式非常强大且有用——匿名和具名之间的区别并不会对这点有任何影响。给函数表达式指定一个函数名可以有效解决以上问题。始终给函数表达式命名是一个最佳实践:

    setTimeout( function timeoutHandler() { // <-- 快看,有名字了! 
        console.log( "I waited 1 second!" );
    }, 1000 );

    立即执行函数表达式

    var a = 2;
    (function foo() { 
        var a = 3;
        console.log( a ); // 3
    })();
    console.log( a ); // 2

    由于函数被包含在一对 ( ) 括号内部,因此成为了一个表达式,通过在末尾加上另外一个 ( ) 可以立即执行这个函数,比如 (function foo(){ .. })()。第一个 ( ) 将函数变成表达式,第二个 ( ) 执行了这个函数。

    这种模式很常见,几年前社区给它规定了一个术语:IIFE,代表立即执行函数表达式 (Immediately Invoked Function Expression)。

    相较于传统的 IIFE 形式,很多人都更喜欢另一个改进的形式:(function(){ .. }())。仔细观察其中的区别。第一种形式中函数表达式被包含在( )中,然后在后面用另一个()括号来调用。第二种形式中用来调用的()括号被移进了用来包装的( )括号中。

    这两种形式在功能上是一致的。选择哪个全凭个人喜好。

    IIFE 的另一个非常普遍的进阶用法是把它们当作函数调用并传递参数进去。

    var a = 2;
    (function IIFE( global ) {
        var a = 3;
        console.log( a ); // 3 
        console.log( global.a ); // 2
    })( window );
    console.log( a ); // 2

    我们将 window 对象的引用传递进去,但将参数命名为 global,因此在代码风格上对全局对象的引用变得比引用一个没有“全局”字样的变量更加清晰。当然可以从外部作用域传递任何你需要的东西,并将变量命名为任何你觉得合适的名字。这对于改进代码风格是非常有帮助的。

    这个模式的另外一个应用场景是解决 undefined 标识符的默认值被错误覆盖导致的异常(虽然不常见)。将一个参数命名为 undefined,但是在对应的位置不传入任何值,这样就可以保证在代码块中 undefined 标识符的值真的是 undefined:

    undefined = true; // 给其他代码挖了一个大坑!绝对不要这样做! 
    (function IIFE( undefined ) {
        var a;
        if (a === undefined) {
            console.log( "Undefined is safe here!" );
        }
    })();

    IIFE 还有一种变化的用途是倒置代码的运行顺序,将需要运行的函数放在第二位,在 IIFE 执行之后当作参数传递进去。

    这种模式在UMD(Universal Module Definition)项目中被广泛使用。尽管这种模式略显冗长,但有些人认为它更易理解。

    var a = 2;
    (function IIFE( def ) { 
        def( window );
    })(function def( global ) {
        var a = 3;
        console.log( a ); // 3 
        console.log( global.a ); // 2
    });

    4、块作用域

    尽管函数作用域是最常见的作用域单元,当然也是现行大多数 JavaScript 中最普遍的设计方法,但其他类型的作用域单元也是存在的,并且通过使用其他类型的作用域单元甚至可以实现维护起来更加优秀、简洁的代码。

    除 JavaScript 外的很多编程语言都支持块作用域,因此其他语言的开发者对于相关的思维方式会很熟悉,但是对于主要使用 JavaScript 的开发者来说,这个概念会很陌生。

    下面两段代码中的变量,都会污染全局作用域。

    for (var i=0; i<10; i++) { 
        console.log( i );
    }
    
    var foo = true;
    if (foo) {
        var bar = foo * 2;
        bar = something( bar ); 
        console.log( bar );
    }

    表面上看 JavaScript 并没有块作用域的相关功能。

    除非你更加深入地研究。

    with

    它不仅是一个难于理解的结构,同时也是块作用域的一个例子(块作用域的一种形式),用 with 从对象中创建出的作用域仅在 with 声明中而非外部作用域中有效。

    try/catch

    JavaScript 的 ES3 规范中规定 try/catch 的 catch 分句会创建一个块作用域,其中声明的变量仅在 catch 内部有效。

    try {
        undefined(); // 执行一个非法操作来强制制造一个异常
    }
    catch (err) {
        console.log( err ); // 能够正常执行! 
    }
    
    console.log( err ); // ReferenceError: err not found

    正如你所看到的,err 仅存在 catch 分句内部,当试图从别处引用它时会抛出错误。

    let

    ES6 引入了新的 let 关键字,提供了除 var 以外的另一种变量声明方式。

    let 关键字可以将变量绑定到所在的任意作用域中(通常是 { .. } 内部)。换句话说,let为其声明的变量隐式地了所在的块作用域。

    var foo = true;
    if (foo) {
        let bar = foo * 2;
        console.log( bar );
    }
    console.log( bar ); // ReferenceError

    但是使用 let 进行的声明不会在块作用域中进行提升。声明的代码被运行之前,声明并不“存在”。
    (提升是指声明会被视为存在于其所出现的作用域的整个范围内。)

    块作用域非常有用的原因和闭包及回收内存垃圾的回收机制相关。

    function process(data) {
        // 在这里做点有趣的事情
    }
    var someReallyBigData = { .. };
    process( someReallyBigData );
    
    var btn = document.getElementById( "my_button" );
    btn.addEventListener( "click", function click(evt) {
        console.log("button clicked");
    }, /*capturingPhase=*/false );

    click 函数的点击回调并不需要 someReallyBigData 变量。理论上这意味着当 process(..) 执 行后,在内存中占用大量空间的数据结构就可以被垃圾回收了。但是,由于 click 函数形成 了一个覆盖整个作用域的闭包,JavaScript 引擎极有可能依然保存着这个结构(取决于具体实现)。

    块作用域可以打消这种顾虑,可以让引擎清楚地知道没有必要继续保存 someReallyBigData 了:

    function process(data) {
        // 在这里做点有趣的事情
    }
    // 在这个块中定义的内容可以销毁了! 
    {
        let someReallyBigData = { .. }; 
        process( someReallyBigData );
    }
    var btn = document.getElementById( "my_button" );
    btn.addEventListener( "click", function click(evt){
        console.log("button clicked");
    }, /*capturingPhase=*/false );

    let循环

    一个 let 可以发挥优势的典型例子就是之前讨论的 for 循环。

    for (let i=0; i<10; i++) { 
        console.log( i );
    }
    console.log( i ); // ReferenceError

    const

    除了 let 以外,ES6 还引入了 const,同样可以用来创建块作用域变量,但其值是固定的 (常量)。之后任何试图修改值的操作都会引起错误。

    var foo = true;
    if (foo) {
        var a = 2;
        const b = 3; //包含在if中的块作用域常量
        a = 3; //正常!
        b = 4; //错误! 
    }
    console.log( a ); // 3
    console.log( b ); // ReferenceError!
    展开全文
  • 分为代码块作用域、函数作用域、文件作用域。代码块是{}之间的一段代码。 2、静态变量 static int I = 0;//定义了一个静态变量 (1)代码块作用域内的静态变量特点 1)只能被这个代码块内部访问; 2)静态...

    1、作用域

    分为代码块作用域函数作用域文件作用域。代码块是{}之间的一段代码。

    2、静态变量

    static int I = 0;//定义了一个静态变量

    (1)代码块作用域内的静态变量特点

    1)只能被这个代码块内部访问;

    2)静态变量在程序刚加载到内存的时候就出现,所以和定义静态变量的大括号无关,一直到程序结束的时候才从内存消失;

    3)同时静态变量的值只初始化一次。

    (2)代码块作用域外的静态变量特点

    1)只能被定义这个变量的文件访问。

    2)static的全局变量在不同的文件中名字是可以相同的。

     

    展开全文
  • Java中的块作用域

    千次阅读 2018-06-26 11:48:10
    (block)的概念(即复合语句)是指由一对花括号括起来的若干条简单的Java语句,确定了变量的作用域,一个可以嵌套在另一个中。下面就是在main方法中嵌套另一个语句的示例,见图1。public class Test{...
  • 额刚刚写了好多,结果被我误操作覆盖掉了,我的心血 ╥﹏╥… 没关系重新写一遍,也提醒同样在这个平台写...什么词法作用域、静态作用域、动态作用域、函数作用域、块作用域 傻傻分不清楚 下面我就给大家理清一下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 258,633
精华内容 103,453
关键字:

块作用域