精华内容
下载资源
问答
  • let var const var关键字 var关键字的用法 js中声明变量的关键字。 var num = 1; 如果在函数作用域中声明,为局部变量;如果在全局中声明,则为全局变量。 num = 2; 这种写法实际上是赋值,如果在函数作用域中赋值...

    let var const

    var关键字

    var关键字的用法

    js中声明变量的关键字。

    var num = 1;
    

    如果在函数作用域中声明,为局部变量;如果在全局中声明,则为全局变量。

    num = 2;
    

    这种写法实际上是赋值,如果在函数作用域中赋值就会去找当前函数作用域中的num,如果当前作用域中没有这个变量就会接着去上一个作用域中寻找,直到找到全局,在全局中如果也并没有声明过这个变量,就会给全局对象window强行添加一个num属性进行赋值。

    var关键字的缺点

    1) var会被声明提前,会打乱程序原本的执行顺序(变量提升传送门

    2) 在ES6之前,js中没有块级作用域,代码块内的变量,极有可能影响到外部的变量。

    let关键字

    ES6中新增的专门代替var用来声明变量的关键词。

    优点:

    1. 不会声明提前

    2. 将js中的程序块变成了一级作用域

    原理:

    1. 从let位置开始,到当前代码块底部,自动建立了匿名函数自调

    2. let在底层还悄悄的修改了内部的变量名: 比如:let t -> let _t

    注意:

    1. 相同作用域中不能let两个同名的变量

    2. let之前不允许提前使用该同名变量

      let生成匿名函数自调是从let位置才开始包裹,let之前的代码不属于匿名函数自调内部,所以无法访问匿名函数内的变量;

      ES6中明确规定如果块级中存在letconst命令时,则这个区块对这些命令声明的变量从一开始就形成封闭的区域,在代码块内,使用let命令前,该变量都是不可用的,这块区域在语法上称为“暂时性死区“

    3. 即使在全局let的变量,也不会保存在window

      实际上保存在了let原理中提到的立即执行匿名函数自调函数的函数作用域中;

      ES6在这方面也有规定:varfunction命令声明的全局变量依旧是顶层对象的属性,而letconstclass命令声明的全局变量不属于顶层对象的属性;也就是说从ES6开始,全局变量逐步于顶层对象的属性隔离。

    let和for循环的化学反应

    //1.
    for(var i = 0; i < 5 ;i++){
    	setTimeout(function(){
    		console.log(i)
    	},500)
    }
    //55555
    //2.
    for(let i=0; i < 5 ;i++){
    	setTimeout(function(){
    		console.log(i)
    	},500)
    }
    //01234
    

    第一题因为定时器是异步任务,会加入到任务队列等待主程序执行完毕在执行。主程序执行循环,当i等于5时,循环条件不满足退出循环,主程序结束,开始执行任务队列中的定时器对象,定时器对象中没有自己局部的i就会去上级作用域中拿,而上级的i主程序结束后就变成了5,所以会输出55555

    实际上第二题在程序中可以看成下面这样运行的(看上边所说的let的原理):

    for(var i=0; i < 5 ;i++){
        (function(i){//外层函数  i为要保护的变量
           setTimeout(function(){//内层函数
    			console.log(i)
    		},500) 
        })(i)
    }
    

    看以上代码,其实就是一个闭包(闭包传送门),每循环执行一次就会生成一个定时器对象并且匿名函数自调中的局部变量 i 都会因为被内层函数中连着无法释放,每次都会生出一个闭包保存当次的 i 的值。当主程序执行结束后,执行任务队列中的定时器对象,定时器对象中没有自己的局部 i 就会去上层找,找到的就是每次匿名函数生成的作用域对象中的 i ,所以输出是01234

    const关键字

    ES6中新增的专门用来声明常量的关键词。

    let的特性const都有,不能反复声明,存在块级作用域,不存在变量提升,也有暂时性死域的特点。

    let区别在于:

    1. const一旦声明就必须赋值;

    2. const声明如果是一个原始类型的常量,一旦声明就无法修改;

    3. const声明如果是一个引用类型的常量,一旦声明,保存在const中的地址值(指针)就无法修改,但是通过地址值指向的对象的属性还是能够修改的。

    const PI;
    //报错 const一旦声明就必须赋值
    const PI=3.1415926;
    PI = 3.14;
    //报错 const一旦声明如果值是原始类型的值,值不能改变
    const obj = {a:1,b:2}
    obj = {};
    //报错 const一旦声明如果值是引用类型的值,地址值不能改变
    

    var let const 对比总结:

    3个方向:1值是否能改变,2作用域在哪,3是否存在变量提升

    1. 使用var声明的变量,其作用域为该语句所在的函数内,且存在变量提升现象,值能修改。

    2. 使用let声明的变量,其作用域为该语句的代码块内,不存在变量提升,值能修改。

    3. 使用const声明的常量,其作用域为该语句的代码块内,不存在变量提升,且常量的值不能修改(原始类型的值和内存地址值不能修改)。

    ps: 学习阮一峰 ES6入门 个人理解心得总结(1)let,const命令 个人理解难免有错误,欢迎大家指正

    展开全文
  • js之变量let var

    2021-01-23 12:12:22
    varlet的区别 let不会被声明提前 console.log(a); var a=10; console.log(b); var b=20; 在相同作用域中,只能有一个let var a=10; var a=100; console.log(a); var b=20; var b=200; console....

    var 声明提前,破坏程序正常的执行顺序

          没有块级作用域,块内的变量,很可能影响到块外的程序

       eg:    <script>
            var t=0;//准备累加每个函数所耗费的时间
            function fun1(){
                console.log(`调用fun1,耗时0.3秒`);
                t+=0.3;
            }
            function fun2(){
                console.log(`调用fun2,耗时0.8秒`);
                t+=0.8;
            }
            fun1();
            fun2();
            console.log(`共耗时${t}秒`);
            </script>

     

    <script>
            var t=0;//准备累加每个函数所耗费的时间
            function fun1(){
                console.log(`调用fun1,耗时0.3秒`);
                t+=0.3;
            }
            function fun2(){
                console.log(`调用fun2,耗时0.8秒`);
                t+=0.8;
                //将来程序进行修改
                //虽然这个程序没有执行,但还是影响了最后结果
                //js中,if和循环的{}都不是作用域
                if(false){
                    var t=new Date();//获得当前系统时间
                    console.log(`今天是:${t.toLocaleString()}`)
                }

            }
            fun1();
            fun2();
            console.log(`共耗时${t}秒`);
            </script>

    let不会被声明提前,让if和循环的{}也变成作用域

        <script>
            var t=0;//准备累加每个函数所耗费的时间
            function fun1(){
                console.log(`调用fun1,耗时0.3秒`);
                t+=0.3;
            }
            function fun2(){
                console.log(`调用fun2,耗时0.8秒`);
                t+=0.8;//这里的t还是全局
                //将来程序进行修改
            
                //let让if和循环的{}变成作用域,t只会影响内部
                if(false){
                    let t=new Date();//获得当前系统时间
                    console.log(`今天是:${t.toLocaleString()}`)
                }
            }
            fun1();
            fun2();
            console.log(`共耗时${t}秒`);
            </script>

    总结:var与let的区别

    let不会被声明提前,var可以被声明提前,也就是var声明了但未赋值

    console.log(a);

    var a=10;

    console.log(b);

    let b=20;//b没有定义

    在相同作用域中,只能有一个let,var可以有多个

    var a=10;

    var a=100;

    console.log(a);

    var b=20;

    var b=200;

    console.log(b);//b已经有了

    在全局创建let变量,在window中找不到,let底层原理等于匿名函数自调

    <script>
             var c=10;
             console.log(window.c);
             console.log(c);
             
             let d=20;
             console.log(window.d);
             console.log(d);
             //let底层原理等于匿名函数自调
             (function(){
                 var d=20;//局部变量
                 console.log(window.d);
                 console.log(d);
             })()
            </script>

     

    展开全文
  • js ES6中 let var const

    2020-08-11 12:54:32
    js ES6中 let var const varlet ES6 新增了let命令,用来声明局部变量。它的用法类似于var,但是所声明的变量,只在let命令所在的代码块内有效 与 var 相比,let 和 const 不存在变量提升。变量提升,指的是在...

    js ES6中 let var const

    var 和let

    ES6 新增了let命令,用来声明局部变量。它的用法类似于var,但是所声明的变量,只在let命令所在的代码块内有效

    与 var 相比,let 和 const 不存在变量提升。变量提升,指的是在变量声明之前就可以使用,只是,在声明之前,变量的值为undefined。var 声明的变量,在全局范围内都有效,而 let 声明的变量,只在 let 所在的作用域内有效。

    首先来看var的变量提升:

     var a = "你好!";
          function fn(){
    
              console.log(a); // 使用a
              //首先查看函数内部有没有定义这个a 变量提升
    
              if(false){
                  var a = "扣肉!"; 
              }
          }
          fn(); //输出undefined
    

    这里吧if语句中的var a提升到到了consol的前面,相当于在consol的前面 有着 var a 但没有对a进行赋值。

    作用域提升 只是把定义 放在前面 赋值还是原来的位置

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

    es6为js新增了块级作用域

       function fn() {
              let a = 5;
    
              if (true) {
                //let a = "扣肉!"; 
                console.log(a); //输出扣肉
              }
              console.log(a); //输出5
            }
            fn();
    

    允许块作用域可以任意嵌套

        	{
                {
                    let a = "1";
                }
                  let a = "2";
                  console.log(a);
            }
    
    var a = [];
          for (let i = 0; i < 10; i++) {
            a[i] = function () {
              console.log(i);//输出1 ,2,3,4,...10;
            };
              //若讲let换成var 则i为全局变量输出的是10。
          }
    

    另外let不存在变量提升:

       console.log(b); //
            var b = 1;
    
           var b;
           console.log(b)
           b = 1
    
            console.log(c); //
            let c = 2;
    

    暂时性死区

    只要块级作用域里面存在let声明 ,它所有声明的变量就会绑定这个区域 不再受外部影响

         var a1 = "苹果";
          if(true){
              a1 = "小欧"; //这一行代码就是一个死区
              let a1; // 变量的赋值 就是使用a1 ES6 规定必须要先声明 再去使用
          }
          console.log(a1);
    

    另外let不能声明同样的变量名

    {报错

    ​ let a = 1;

    ​ let a = 2;

    ​ }

     var a = 0;
            // ES5 全局的变量 是挂在 window下面 
            console.log(window.a);
            let b = 1; 
            console.log(b);
            {
                console.log(b);
            }
    

    const

    const定义的变量不可以修改,而且必须初始化

    const b = 2;//正确
     // const b;//错误,必须初始化 
     console.log('函数外const定义b:' + b);//有输出值
     // b = 5;
     // console.log('函数外修改const定义b:' + b);//无法输出 
    
    展开全文
  • let var const的区别

    2018-04-13 08:44:23
    let var const的区别 const:是修饰全局变量,且不可修改(基本数据类型变量),必须给定初始值,类似java当中的final; let:是用于块区域当中,通常是在函数内部使用,作用域也是在函数范围内,防止全局污染 var:...

    let var const的区别

    1. const:是修饰全局变量,且不可修改(基本数据类型变量),必须给定初始值,类似java当中的final;
    2. let:是用于块区域当中,通常是在函数内部使用,作用域也是在函数范围内,防止全局污染
    3. var:用在函数外面则是全局变量,用在函数内部则是局部变量
    展开全文
  • let var const

    2018-07-20 15:51:00
    eslint要求变量声明使用const的,而不是letvar如果可能的话。 如果一个变量只有在声明时才被赋值一次,那么应该使用'const' 'use strict';(function() { var varTest = 'test var OK.'; let letTest = 'test ...
  • js let var const

    2021-05-08 22:30:45
    letvar的用法类似,但是letvar的作用域却又区别 var可以在声明之前使用,只不过这时候对于var声明的变量,声明之前对应变量的值是undefined,但是let却不是,如果let声明的变量,在声明之前使用,会直接报错。...
  • let var const 总结

    2020-10-09 21:30:39
    首先总结下let/var/const三者的区别与联系 总结 1.letvar和const的区别 let没有变量提升,var有,所谓的变量提升即能否在声名变量前访问变量 let 有块级作用域,var没有,所以if for等块对var来说没有限制作用,...
  • Js变量提升以及暂时性死区let var区别 p90 在使用var声明变量时候如果是在声明变量之前就使用,则变量会被提升到作用域顶端,,严格上来let也会提升,但是由于“暂时性死区”的缘故,不能再声明之前使用let。 console...
  • ES6之let var const

    2020-05-05 15:37:39
    letvar区别 let 没有变量提升,var
  • js 的 let var const 区别

    2021-04-26 22:23:55
    letvar 都用来声明变量 let 变量一定要先声明再使用, 而 var 变量可以先使用再声明 (先使用的值是 undefined) 相同作用域 let 变量不能重复声明, 而 var 变量可以重复声明 /* letvar 都用来声明变量 ...
  • 闭包以及let var

    2018-05-30 12:23:28
    var list = document.getElementById('list'); for (let i = 1; i &lt;= 5; i++) { let item = document.createElement('li'); item.appendChild(document.createTextNode('Item ' + i)); item.onclick = ...
  • js let var和const的区别

    2021-04-29 11:02:49
    letvar的区别 varHandle:function(){ var index = 11; if(true){ varindex =22; console.log(index); // 22 } console.log(index); // 22 } letHandle:function(){ let index = 11; if(true...
  • let var声明变量的不同

    2021-06-07 15:19:40
    1、var声明变量可以重复声明,后一次声明的变量值会覆盖前次声明的值,而let会直接报错 2、var声明没有块级作用域,let声明有块级作用域
  • const与let 一样不可重复声明,var可以重复申明变量 (2). var 是函数级作用域,let是块级作用域 例子:  {  let n = 10;  var m = 1;  }  结果:n // 会报错:ReferenceError:a is not defined.  结果:m // 1
  • ES6 let var 语法区别

    2017-05-12 16:21:06
    let 关键字 只在let命令所在的代码块内有效。var a = [] for(let i = 0;i ;i++){ a[i] = function(){ console.log(i) } } a[6]() //6var 关键字 在全局范围内都有效var a = [] for(var i = 0 ; i ; i++){ a[i]...
  • js中 let var const 的差异和使用场景

    千次阅读 2018-08-15 11:32:03
    微信小程序开发交流qq群 173683895 承接微信小程序开发。扫码加微信。 正文: ...其中,let完全可以取代var,因为两者语义相同,而且let没有副作用。 'use strict'; if (true) { let x = '...
  • let var和const

    2017-09-21 22:15:39
    es6新增了let命令,但是let所声明的变量只在let命令所在的代码块有效,比如上个代码, 打印的是b==1 下一个打印直接报错,a is not defined 所以for循环很适合let for(let i = 0; i ; i++) {} 但是for循环...
  • ES6 let var 暂时性死区

    2017-05-12 16:56:48
    var age = 2let在变量定义前不可调用console.log(name) //ReferenceError let name = 'tom'暂时性死区(temporal dead zone,简称 TDZ) 下面代码中,存在全局变量tmp,但是块级作用域内let又声明了一个局
  • 在vue中let var 和const 区别

    万次阅读 2018-11-17 19:39:54
    let和const 使用方法:  (1).有没有感觉到在 javascript 使用var会发生变量提升,即脚本开始运行时,  变量已经存在了,但是没有值,所以会输出undefined。... var 是函数级作用域,let是块级作用域...
  • 可以看到 var a ; 在没有赋值的时候 可以输出 但是显示undefined; let同上,那么const呢 很明显会报错 显示 const声明的a没有初始化 当 var a=1; 输出结果是1 再次声明 a=2 会覆盖 a=1; let一样 会输出a=1...
  • letvar var let 总结 const 笔记 letvar var const list = [1, 2, 3, 4, 5] for (var i = 0; i list.length; i++) {} // 输出结果 5 console.log(i) // 可以看出 var 并没有被清空 ...
  • js中的let var const

    2019-02-27 10:31:55
    const定义的变量不可以修改,而且必须初始化。 var定义的变量可以修改,如果不初始化会输出undefined,不会报错。...let是块级作用域,函数内部使用let定义后,对函数外部无影响。
  • ios8 swift开发:let var 区别讨论

    千次阅读 多人点赞 2014-07-01 13:26:59
    localhost:~ hejiasheng$ xcrun swift Welcome to Swift! Type :help for assistance. 1> var a:Int a: Int = 0 2> let b:Int :2:5: error: 'let' declarations require an initializer expression let b:Int
  • letvar的区别

    2017-12-11 19:18:46
    let var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]; 参数 var1, var2, …, varN变量名。可以是任意合法的标识符。value1, value2, …, valueN变量的初始值。可以是任意合法的表达式。 描述

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 37,636
精华内容 15,054
关键字:

letvar