精华内容
下载资源
问答
  • var和let区别

    2020-08-30 18:54:16
    let、const 相比,var 有 4 个重要的区别: 1、var 没有块级作用域。而如果一个代码块中存在 let const ,则这个代码块就对这些命令声明的标识符形成了一个封闭的作用域,只要在这个代码块外访问这些标识符,...

    与 let、const 相比,var 有 4 个重要的区别:
    1、var 没有块级作用域。而如果一个代码块中存在 let 和 const ,则这个代码块就对这些命令声明的标识符形成了一个封闭的作用域,只要在这个代码块外访问这些标识符,就会报错。
    2、var 存在变量提升,即可以在使用后声明,因为 var 会在声明完初始化 undefined 值,let 在创建完后不会立即初始化,而是 uninitialized ,所以在声明前不能使用。当然可以把 let 粗略的理解为 “创建提升”。
    3、var 可以重复多次声明一个变量,只不过会被忽略,但不会报错。let 则不能存在同名变量,即使它们分别是用 var 和 let 命令创建的也不行。
    4、在全局用 var 声明的变量会自动绑定到 window 对象,let 则不会,但它们都可以修改 window 对象的一些属性。
    其实,块级变量是一个非常棒的东西。这就是为什么 let 在很久以前就被引入了标准,并且现在是声明变量的主要方法 (与 const 一起) 。
    最后还是希望能够在现代的 JavaScript 开发中用 let 、const 来声明变量和常量。如果确定继续使用 var ,请一定记住上面所讨论的问题。

    参考文档 很全https://www.runoob.com/note/51823

    展开全文
  • 在JavaScript中有三种声明变量的方式:var、let、const。但是有朋友不清楚这三种声明变量的区别,下面脚本之家小编给大家详细介绍下js中const、var和let区别,感兴趣的朋友一起看看吧
  • 一、let const 1、相同点:  只在声明所在的块级作用域内有效。  不提升,同时存在暂时性死区,只能在声明的位置后面使用。  不可重复声明。 2、不同点:关于基本类型组成的变量常量 let声明的变量可以...

    一、let 和const

    1、相同点:

     只在声明所在的块级作用域内有效。

     不提升,同时存在暂时性死区,只能在声明的位置后面使用。

     不可重复声明。

    2、不同点:关于基本类型组成的变量和常量

    let声明的变量可以改变,值和类型都可以改变;const声明的常量不可以改变,这意味着,const一旦声明,就必须立即初始化,不能以后再赋值。

    
    const i ; // 报错,一旦声明,就必须立即初始化
    const j = 15;
    j = 20; // 报错,常量不可以改变

    数组和对象等复合类型的变量,变量名不指向数据,而是指向数据所在的引用地址。const只保证变量名指向的引用地址不变,但是并不保证该地址的源数据不变。所以引用类型的常量可以改变,切只能修改源数据。

    const arr = [];
    arr = [1,2,3];
    // 报错,[1,2,3]与[]不是同一个地址  这就是为什么声明后要立即赋值,否则地址发生了变化
    
    const arr = [];
    arr[0] = 1;
    arr[1] = 2;
    arr[2] = 3;
    // 不报错,变量名arr指向的地址不变,只是数据改变
    console.log(arr.length); // 输出:3
    

    若想让定义的对象或数组的数据也不能改变,可以使用object.freeze(arr)进行冻结。冻结指的是不能向这个对象或数组添加新的属性,不能修改已有属性的值,不能删除已有属性。

    const arr = [];
    Object.freeze(arr);
    // 不报错,但数据改变无效
    arr[0] = 1;
    arr[1] = 2;
    arr[2] = 3;
    console.log(arr.length); // 输出:0

    二 var和let 区别:

    在es5中var定义的变量存在变量提升,es6中使用的let不存在变量提升:

    1 console.log(i);
    2 var i = 10;  //10
    3 
    4 console.log(s);
    5 let s = 20;  //ReferenceError: can't access lexical declaration `s' before initialization

    es5中无论if语句是否执行,在if语句内的函数声明都会提升到当前的作用域的顶部而得到执行,es6支持块级作用域,无论是否进入if,内部的函数都不会影响到外部的函数

    //es5环境
     2 function f(){
     3   console.log('outside');
     4 }
     5 if(true){                提升到当前的作用域的顶部而得到执行
     6   function f(){
     7     console.log('inside');
     8   }
     9 }
    10 
    11 f(); //inside
    12 
    13 
    14 //es6环境
    15 function d(){
    16   console.log('outside');
    17 }
    18 if(true){
    19   function d(){
    20     console.log('inside');
    21   }
    22 }
    23 
    24 d(); //outside

    我们最常遇到的循环事件绑定i产生的闭包问题,是因为i绑定在全局,每次访问都会取到全局的i的值,所以访问哪个元素,得到的i都是循环体最后一轮的i。我们通常的解决办法是借助IIFE。在es6中let定义的i只在循环体内有效,所以每次循环i都是一个新的变量,于是会产生正常的输出:

     1  //使用var
     2 var arr1 = [];
     3 for (var i = 0; i < 10; i++) {
     4     arr1[i] = function() {
     5         console.log(i);
     6     }
    
          //  (function(i){   //这里的i类似形参  可以使用IIFE来执行
          //         arr[i].onclick = function (){  
          //           console.log(i); 
          //     } 
          //   })(i);  
     7 }
     8 
     9 arr1[5](); //10
    10 arr1[8](); //10
    11 
    12 //使用let
    13 var arr2 = [];
    14 for (let i = 0; i < 10; i++) {
    15     arr2[i] = function() {
    16         console.log(i);
    17     }
    18 }
    19 
    20 arr2[5]();  //5
    21 arr2[8]();  //8

     

    展开全文
  • let声明的变量可以改变,值类型都可以改变;const声明的常量不可以改变,这意味着,const一旦声明,就必须立即初始化,不能以后再赋值。 const i ; // 报错,一旦声明,就必须立即初始化const j = 15;j...

    1、相同点:

     只在声明所在的块级作用域内有效。

     不提升,同时存在暂时性死区,只能在声明的位置后面使用。

     不可重复声明。

    2、不同点:关于基本类型组成的变量和常量

    let声明的变量可以改变,值和类型都可以改变;const声明的常量不可以改变,这意味着,const一旦声明,就必须立即初始化,不能以后再赋值。

    1. const i ; // 报错,一旦声明,就必须立即初始化
    2. const j = 15;
    3. j = 20; // 报错,常量不可以改变

    数组和对象等复合类型的变量,变量名不指向数据,而是指向数据所在的引用地址。const只保证变量名指向的引用地址不变,但是并不保证该地址的源数据不变。所以引用类型的常量可以改变,切只能修改源数据。

    1. const arr = [];
    2. arr = [1,2,3];
    3. // 报错,[1,2,3]与[]不是同一个地址 这就是为什么声明后要立即赋值,否则地址发生了变化
    4. const arr = [];
    5. arr[0] = 1;
    6. arr[1] = 2;
    7. arr[2] = 3;
    8. // 不报错,变量名arr指向的地址不变,只是数据改变
    9. console.log(arr.length); // 输出:3

    若想让定义的对象或数组的数据也不能改变,可以使用object.freeze(arr)进行冻结。冻结指的是不能向这个对象或数组添加新的属性,不能修改已有属性的值,不能删除已有属性。

    1. const arr = [];
    2. Object.freeze(arr);
    3. // 不报错,但数据改变无效
    4. arr[0] = 1;
    5. arr[1] = 2;
    6. arr[2] = 3;
    7. console.log(arr.length); // 输出:0

    二 var和let 区别:

    在es5中var定义的变量存在变量提升,es6中使用的let不存在变量提升:

    1. 1 console.log(i);
    2. 2 var i = 10; //10
    3. 3
    4. 4 console.log(s);
    5. 5 let s = 20; //ReferenceError: can't access lexical declaration `s' before initialization

    es5中无论if语句是否执行,在if语句内的函数声明都会提升到当前的作用域的顶部而得到执行,es6支持块级作用域,无论是否进入if,内部的函数都不会影响到外部的函数

    1. //es5环境
    2. 2 function f(){
    3. 3 console.log('outside');
    4. 4 }
    5. 5 if(true){ 提升到当前的作用域的顶部而得到执行
    6. 6 function f(){
    7. 7 console.log('inside');
    8. 8 }
    9. 9 }
    10. 10
    11. 11 f(); //inside
    12. 12
    13. 13
    14. 14 //es6环境
    15. 15 function d(){
    16. 16 console.log('outside');
    17. 17 }
    18. 18 if(true){
    19. 19 function d(){
    20. 20 console.log('inside');
    21. 21 }
    22. 22 }
    23. 23
    24. 24 d(); //outside

    我们最常遇到的循环事件绑定i产生的闭包问题,是因为i绑定在全局,每次访问都会取到全局的i的值,所以访问哪个元素,得到的i都是循环体最后一轮的i。我们通常的解决办法是借助IIFE。在es6中let定义的i只在循环体内有效,所以每次循环i都是一个新的变量,于是会产生正常的输出:

    1. 1 //使用var
    2. 2 var arr1 = [];
    3. 3 for (var i = 0; i < 10; i++) {
    4. 4 arr1[i] = function() {
    5. 5 console.log(i);
    6. 6 }
    7. // (function(i){ //这里的i类似形参 可以使用IIFE来执行
    8. // arr[i].onclick = function (){
    9. // console.log(i);
    10. // }
    11. // })(i);
    12. 7 }
    13. 8
    14. 9 arr1[5](); //10
    15. 10 arr1[8](); //10
    16. 11
    17. 12 //使用let
    18. 13 var arr2 = [];
    19. 14 for (let i = 0; i < 10; i++) {
    20. 15 arr2[i] = function() {
    21. 16 console.log(i);
    22. 17 }
    23. 18 }
    24. 19
    25. 20 arr2[5](); //5
    26. 21 arr2[8](); //8

     

    展开全文
  • var和let区别简述

    2020-04-22 22:43:49
    https://www.cnblogs.com/tu-0718/p/11429779.html
    展开全文
  • js中var和let区别

    2018-05-30 10:09:00
    1、区别var定义的变量是全局变量或者函数变量。 let定义的变量是块级的变量。 2、全局变量: 指没有定义在任何函数内,直接定义在全局作用域中的变量。 特点:随处可用,可重用。 何时:希望随处可用,且...
  • let和var区别let和var的全局作用域let和var在面试题中常出现的例子变量提升 let和var的全局作用域 let 和var 声明变量在全局作用域中时 用法相似 let a = ‘apple’; var b = ‘banana’; 但let声明的的变量不能被...
  • JS中const、var和let区别

    2018-06-23 10:09:26
    主要内容是:js中三种定义变量的方式const, varlet区别。1.const定义的变量不可以修改,而且必须初始化。const b = 2;//正确 // const b;//错误,必须初始化 console.log('函数外const定义b:' + b);//有输出...
  • 在目前的前端开发中,let ... 本文主要介绍let var区别和变量提升的奥秘。 var 带来的麻烦 先来看一道前些年很流行的面试题: var data =[] function doSomething () { for (var i = 0; i < 5; i++) { ...
  • 在ES5之前因为iffor都没有块级作用域的概念,所以在很多时候,我们都必须使用function函数的作用域来解决应用外面变量的问题,(因为function作用域中他只管传进去的参数在自己地盘的变化,此参数在之前的行为不归...
  • 微信小程序之 var和let区别

    千次阅读 2019-07-19 11:22:39
    letlet的方式声明的变量,为局部变量,该变量只会在最靠近{ }内的范围有效,出了{}之后,该变量就不能够再用了,否则会报该变量未定义的错误。也就是说,该变量的作用域为所在的代码块内。 //index.js //获取应用...
  • 3.let是块级作用域,函数内部使用let定义后,对函数外部无影响。 let c = 3; console.log( '函数外let定义c:'   + c); //输出c=3 function   change(){ let c = 6; console.log( '函数内let定义c...
  • 1 var和let区别 let左右范围在块里面,var定义的变量可提升,用let声明的变量不可以声明2次 2 简单解构 let [a, b, c] = [1, 2, 3]; 3 map对象遍历 const map = new Map(); map.set('first', '...
  • const 由 const 定义的变量不可以修改,而且必须初始化。...由 var 定义的变量可以修改,如果不初始化会输出undefined,不会报错。例如: 结果: 并且用var声明并初始化后的变量的值可以更改 结果...
  • var i=0; setTimeout(()=>{console.log(i),10}); { var i =1; setTimeout(()=>{console.log(i),10}); { var i=2; setTimeout(()=>{console.log(i),10}) } } } // 2 2 2 /** * 拥有函数定义...
  • var和let区别

    2020-08-08 10:07:37
    var和let声明变量最大的区别是 var是与函数作用域绑定的(function scoped) let是与块级作用域绑定的(block scoped) 此外,var还有变量提升(var declaration hoisting)的问题,但let没有这个,因此不存在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,042
精华内容 1,216
关键字:

var和let区别