let、const、var 的区别有哪些？

[YvetteLau]

[yuzhang9804]

• let 和 var 声明一个变量, const 声明一个只读的常量
• let 和 const 不存在变量提升, var会发生变量提升
• let和const存在暂时性死区, 凡是在声明之前使用这些变量就会报错
• let 和 const 不允许在相同作用域内, 重复声明一个变量
• let 和 const 存在块级作用域
• const 保证的变量保存的数据不得改动, 但如果将一个对象声明为变量, const只能保证这个指针是固定的, 对于它指向的数据结构就不能控制

const person = {
	name: `zhang`
}
person.name = `yu`;
console.log(person.name);		// `yu`

[Jinminrui]

let 和 const 都是块级声明的一种。 块级声明用于声明在指定块的作用域之外无法访问的变量。 let 和 const 不同于 var 的特点如下：

1. 不存在变量提升
2. 不可以重复声明
3. 不绑定全局作用域

let 和 const 的区别： const 用于声明常量，其值一旦被设定不能再被修改，否则会报错。 此外，const 声明不允许修改绑定，但允许修改值。这意味着可以修改const声明的对象中的属性。

[shenanheng]

var的作用: a:可以声明变量以及常量 b:可以变量提升,默认为undefined,当运行到给变量赋值才会赋值 c:作用域为函数作用域 d:允许在相同作用域内, 重复声明一个变量

let与const:

相同点: a:作用域为块作用域 b:没有函数提升 c:不允许在相同作用域内, 重复声明一个变量

异同点: a:let一般声明的是变量(也可以弄为常量,不建议);const声明的是常量(必须初始化),当为对象的时候属性的值是可以改变的

[mcDullLi]

let和const声明都在代码块内有效。不存在变量提升。相同作用域内，不能重复命名。 const声明的是只读常量，指向的内存地址不能改动。一旦声明，必须立即初始化。 var用于声明在函数作用域内有效，允许变量提升。相同作用域内，可以重复声明

[lianbo666]

全局声明的var变量会挂载到window上，而let和const不会； var声明变量存在变量提升，let和const不会； let，const的作用范围是块级作用域，而var的作用范围是函数作用域； 同一作用域下let和const不能同时声明同名变量，而var可以； 同一作用域下在let和const声明前使用会存在暂时性死区； 对于const来说：一旦声明必须赋值,不能使用null占位，声明后不能再修改，如果声明的是复合类型数据，可以修改其属性

[killbymywind]

let和const都是作用于代码块的声明，var 的作用域是当前 scope 的所有子作用域，包括当前作用域中声明或调用的函数或是 while / for / if / try-catch 语法区块。let和const都是es5，es6新版本的js语言规范出来的定义，在这以前定义一个变量只能用var。var存在变量提升，let，const不存在。let，const不允许重复声明同一变量，而var可以

[freeshineit]

var [ECMAScript 1st Edition (ECMA-262)规范]

• var 存在变量提升(可以在使用之后定义，值为undefined)
• 作用在函数作用域上

let [ECMAScript 2015 (6th Edition, ECMA-262)规范]

• let 语句声明一个块级作用域的本地变量，并且可选的将其初始化为一个值。
• let 定义的变量 必须先定义后使用

const[ECMAScript 2015 (6th Edition, ECMA-262)规范]

• 作用在块级作用域上
• 定义时就要赋值
• 一般是用来定义常量（变量值不允许重新赋值）

var vs let vs const in JavaScript

JavaScript中var、let、const区别？

[zihuasunshine]

1. let、const是块级作用域
2. let、const不存在变量提升，要先声明才能使用, 如果在声明之前使用，会报错，被称为‘暂时性死区’，这意味typeof不再是一个百分之百的操作
3. let、const在相同作用域不允许重复声明
4. const声明不赋值会报错，一旦赋值就不允许改变，对于复杂数据类型，不允许改变是指不能改变引用类型的指向。 5.顶层let、const声明的变量，不会成为global对象的属性；

[0uzu0]

[woyiweita]

var

• 声明变量
• 可以重复多次声明，后声明的会覆盖先声明的
• 没有块级作用域
• 变量可以被改写
• 变量可提升，提前访问返回undefined

---

let

• ES6新提出的变量声明关键字，用于声明变量
• 有块级作用域
• 不可重复多次声明
• 变量可以被改写
• 变量不提升，先声明再应用，提前访问提示错误信息

---

const

• ES6新提出的常量声明关键字，用于声明常量
• 有块级作用域
• 不可重复多次声明
• 常量值如果是基础数据类型，不可改写，如果是引用数据类型，不可改写常量指针，但可修改对象属性及属性值
• 常量不提升，需要先声明再应用，提前访问提示错误信息
• 常量声明时就需要完成赋值操作

[daibin0809]

• var与let/const的区别
  1. var声明在在方法内为全局变量，声明在方法外为局部变量；let/const无法声明为全局变量。
  2. var存在变量提升，在赋值前为undefined；let存在暂时性死区，块级作用域中使用了let声明就会'绑定'区域，声明前不能使用；const声明时必须赋值。
  3. var不存在块级作用域；let/const存在。
  4. for循环中计数变量为var时，只存在一个变量；let/const每次循环都是一个新的变量，与循环体为不同作用域。
  5. var可重复声明，let/const在作用域中不允许重复声明。
• let与const的区别
  1. const声明时必须赋值。
  2. const声明后不可改变。不可改变指的是地址，而不是值。

[xiatiandenixi]

1. const和let存在块级作用域，var不存在。
2. const和let存在暂时性死区，var不存在。
3. var存在变量提升，const和let木有。
4. const 声明变量时需要赋值，var和let不需要。
5. const和let不可重复声明变量，var可以。

[AILINGANGEL]

1.变量提升

var会进行变量提升，let和const不会进行提升

2.暂存死区

因为var会进行变量提升，所以可以在声明之前访问，不会形成暂存死区。let 和const 不会进行变量提升，在声明之前不能使用，形成暂存死区

3.重复声明

var可以进行重复声明，但是let和const不能进行重复声明

4.块作用域

var不会形成块作用域，let和const可以形成块作用域

5.重新赋值

var和let声明的变量可以重新赋值，const不可以。如果const 声明的变量存储的是引用地址, 是可以修改这个引用对应的对象的值的，但是这个变量不能被赋予其他值

[ChasLui]

	var	let	const
变量提升	Y	N	N
覆盖全局变量	Y	N	N
重复声明	Y	N	N
暂时性死区	N	Y	Y
块作用域	N	Y	Y
只声明不初始化	Y	Y	N
重新赋值	Y	Y	N

[riluocanyang]

let、const、var的区别有哪些？

js本身只有全局作用域和函数作用域，let和const的出现，使得js有了块级作用域。 1、var 声明的变量可以重复，而let、const则不可以； 2、var 声明的变量可以提升，而let、const则不可以； 3、let声明的变量的值可以更改，而const声明的是常量，则不可以，如果const声明的一个对象，则对象中的属性值可以改变； 4、for循环中用var 声明的变量可以在for循环外访问到，而let则不可以。

for(var i = 0; i < 10; i++) {
}
console.log(i)    // 10
for(let j = 0; j < 10; j++) {
}
console.log(j)   // Uncaught ReferenceError: j is not defined

[jodiezhang]

let 和 const都是ES6新增的 在let和const没有出来的时候，JS没有块级作用域，只有全局作用域和函数作用域。

  for(var i=0;i<10;i++){
          var a = 'a';
    }

    console.log(a);

比如上面这个例子，已经不在for循环中了，已经跳出这个块了，我们还是能打印出 a 再看下面这个例子

for (var i = 0; i < 3; i++) {
      setTimeout(function () {
        console.log(i)
      }, 1000);
 }

3 3 3 而不是 1 2 3 循环本身以及三次timeout回调共享了变量i

let的出现让变量拥有块级作用域，把上面的var 换成 let 可以完美解决问题。

我们总结一下var ，let， const 的区别 1.变量提升 var

console.log(a);//undefined
var a=2;

let

console.log(a);//Uncaught ReferenceError: Cannot access 'a' before initialization
var a=2;

const

console.log(a);//Uncaught ReferenceError: Cannot access 'a' before initialization
const a=2;

2.暂时性死区 作用域中声明了let变量，但是let变量的使用却在声明之前，这通常叫做变量提升。 但是let并不像var一样，var变量声明前使用，会打印出undefined.但是let变量直到被赋值才会被初始化。 在变量被初始化前访问这个变量会报reference error.我们称这个变量在作用域开始到被初始化之间为暂时性死区。

function do_something() {
  console.log(bar); // undefined
  console.log(foo); // ReferenceError

  var bar = 1;
  let foo = 2;

}

3.重复声明

 let a=1;
 let a=2;

//报错

 const a=1;
 const a=2;

//报错

 var a=1;
 var a=2;

//不报错

4.重新赋值

var和let可以重新赋值，但是const不可以，而且const 必须声明的时候就初始化。

[shenshuangdao]

1、var和let声明一个变量, const 声明一个只读的常量； const保存对象时保存的是一个地址的指针，所以可以修改对象的值：

2、const必须在声明的时候就初始化，var和let不用；

3、var可以重复声明，let和const不可以；

4、var会声明提前，let和const不会声明提前，let 和 const 存在暂时性死区, 凡是在声明之前使用这些变量就会报错；

----暂时性死区：当程序的控制流程在新的作用域进行实例化时，在此作用域中用let/const声明的变量会先在作用域中被创建出来，但因此时还未进行词法绑定（对声明语句进行求值运算），所以不能被访问（访问就会抛出错误）。所以在这运行流程进入作用域创建变量，到变量开始被访问之间的一段时间，就称之为temporal dead zone，简称TDZ。

5、let和const 是块级作用域，var不是

6、var声明最外层是在全局下建一个变量，let和const不会

7、let和const 是ES6新命令

（本来也想画个图发现前面的图已经很好了果然都是大佬。。。）

[Liruimin2]

• var 定义变量变量会提升，let const不会变量提升let 和 const 存在块级作用域
• let 和 var 声明一个变量, const 声明一个只读的常量，const一旦定义了不能修改
• let和const存在暂时性死区, 凡是在声明之前使用这些变量就会报错
• let 和 const 不允许在相同作用域内, 重复声明一个变量

[xiaokinglong]

1. var 声明的变量会提升, 而let和const不会提升变量

console.log(a) // 打印的是undefined
var a = 10
console.log(b) // 直接报错
let b = 10
console.log(c) // 直接报错
const c = 10

2. 使用var声明的变量的没有块级作用域, 而使用的let和const是有块级作用域的

{
var a = 10
}
console.log(a) // 10
{
let b = 10
}
console.log(a) // 直接报错 b 未定义
{
const c = 10
}
console.log(c) // 和let一样

3. var可以相同的作用域中重复定义的一个变量,而let和const使用不可以的
4. 在相同的作用域中let声明的变量是可以重新的赋值的, 而使用的const声明的变量时候就给变量赋值, 之后也不能重新赋值

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

{
const b; // 直接报错
console.log(b)
const c = 10;
c = 100 ;// 直接报错
}

[callmebetter]

let、const是ES6声明变量的方式，与var相比：

• const、let声明的变量具有块级作用域
• const、let声明的变量无法在当前作用域范围内重复声明
• const、let只能先声明再使用

let、const对比

• const声明的变量不能再次赋值，但是引用类型的值依然可以改变
• const声明的变量必须初始化

[gaoluona]

• let 声明一个变量，仅可在声明变量的块级作用域使用

• const 声明一个只读常量，不可修改，与 let 同存在块级作用域

• var 声明一个变量，变量可提升，在声明前就可以使用，变量可重复声明

[jackluson]

1. var是js申明变量最原始的一种,let,const是es6新语法,主要是弥补了类似其他语言申明常量,变量,块作用域方面的不足,
2. let可以让变量有块级作用域,比如这个例子

for (var i = 0; i < 3; i++) {
     setTimeout(function () {
       console.log(i) // 0,1,2 如果用var 打印出来就是333
     }, 1000);
}
3. const定义常量(申明时必须有初始值),let定义变量,两者不存在变量提升,先申明在使用,而且不能重复申明

[lqzo]

1. 作用域 let 声明的变量 和 const 声明的常量只在声明所在的块级作用域内有效；var 声明的变量的作用域是函数作用域。

if (true) {
  const MAX = 5;
  let a = 10;
  var b = 1;

  MAX // 5
  a // 10
  b // 1
}
MAX // Uncaught ReferenceError: MAX is not defined
a // ReferenceError: a is not defined.
b // 1

2. 重复声明 let 和 const 不允许在相同作用域内重复声明；var 可以。

let foo;
let foo; // TypeError thrown.

3. 声明提前（变量提升） var 声明会发生“变量提升”现象，即变量可以在声明之前使用，值为undefined；let 和 const 不会。

4. 暂时性死区 let 和 const 存在暂时性死区, 凡是在声明之前使用这些变量就会报错；var 不存在。

function do_something() {
  console.log(bar); // undefined
  console.log(foo); // ReferenceError: foo is not defined
  var bar = 1;
  let foo = 2;
}

ES6 规定暂时性死区和let、const语句不出现变量提升，主要是为了减少运行时错误，防止在变量声明前就使用这个变量，从而导致意料之外的行为。 暂时性死区的本质就是，只要一进入当前作用域，所要使用的变量就已经存在了，但是不可获取，只有等到声明变量的那一行代码出现，才可以获取和使用该变量。

5. 重新赋值 let 和 var 声明的变量可以重新赋值； const 声明的是常量，不得改变值，这意味着，const一旦声明，就必须立即初始化，不能留到以后赋值。

const foo;
// SyntaxError: Missing initializer in const declaration
// 对于const来说，只声明不赋值，就会报错。

let 和 const 作为 ES6 新增的命令，相较 var 有更多的特性，更多内容可以点击下面链接查看: var - JavaScript | MDN let - JavaScript | MDN const - JavaScript | MDN let 和 const 命令 - ECMAScript 6 入门

[xdandsl]

1，什么时候提出的？

var是ES5提出的，let和const是ES6提出的。

2，是否存在变量提升？

var声明的变量存在变量提升（将变量提升到当前作用域的顶部）。即变量可以在声明之前调用，值为undefined。 let和const不存在变量提升。即它们所声明的变量一定要在声明后使用，否则报错。

3，是否存在暂时性死区？

let和const存在暂时性死区。即只要块级作用域内存在let命令，它所声明的变量就“绑定”（binding）这个区域，不再受外部的影响。 **在代码块内，使用let命令声明变量之前，该变量都是不可用的。**这在语法上，称为“暂时性死区”（temporal dead zone，简称 TDZ）。 总之，暂时性死区的本质就是，只要一进入当前作用域，所要使用的变量就已经存在了，但是不可获取，只有等到声明变量的那一行代码出现，才可以获取和使用该变量。

4，是否允许重复声明变量？

var允许重复声明变量。let和const在同一作用域不允许重复声明变量。

5，是否存在块级作用域？

var不存在块级作用域。let和const存在块级作用域。 到底什么叫块级作用域呢， JS中作用域有：全局作用域、函数作用域。没有块作用域的概念。ECMAScript 6(简称ES6)中新增了块级作用域。块作用域由 { } 包括，if语句和for语句里面的{ }也属于块作用域。

6，是否能修改声明的变量？

var和let可以。 const声明一个只读的常量。一旦声明，常量的值就不能改变。const声明的变量不得改变值，这意味着，const一旦声明变量，就必须立即初始化，不能留到以后赋值。

[0xe69e97]

let 局部作用域变量，有暂时性死区特性 const 局部作用域常量，有暂时性死区特性 var 变量提升特性

[darlingyz]

let const 是es6引入的新的语法。 var 存在语法提升，会造成内存泄漏 并且 在一个函数总var 可以声明多个一样的变量 eg:var a=1, a=2, a=3; let 在函数中声明的时候不存在语法提升，不会造成内存泄漏 并且存在块级作用域，只有在块级作用域中才能生效 let 的语法比较严格，如果是声明的相同的变量就会报错(如果是在不同的块级作用域中，即使声明一样的也不会报错) eg://想了个简单的例子，不知道妥不妥当 :-) function hello() { let a = 0; console.log(a, 'hello') if (true) { let a = 0; console.log(a, 'obj') } } let b = new hello() console.log(b) const定义的变量不可以修改，而且必须初始化 如果const 声明的是对象，那么是可以改变的 const obj ={ name:'Hello', age:18 } obj.name='Hello world' console.log(obj)

[liangchengxiaohuo]

1、var声明的变量会存在变量提升，let和const不存在变量提升 2、var声明的变量会挂载在windows上，let和const声明的变量不会 3、同一个作用域下let和const声明的变量不能同名，但是var可以 4、const一旦声明就必须赋值不能使用null占位，并且声明的不能被修改 5、let和const声明的变量会形成块作用域

[yangyiqiqia]

var 和 let 用来声明变量，const 只能声明一个只读的常量 let 和 const 具有块级作用域，在作用域之外不可被访问 var 声明的变量存在变量提升，let和const的不存在变量提升 ，在声明之前访问用var定义的变量返回undefined，let和const会直接报错 var 定义的变量可以重复多次声明，后者会覆盖前者，let 和 const 重复声明会报错

[Diamondjcx]

var 和 let都是用来定义变量的，而const 是用来定义常量的

• 1.变量提升: var声明的变量会被提升，let和const不会。let 和 const 存在暂时性死区, 凡是在声明之前使用这些变量就会报错；

consle.log(a)  // 可以直接打印
var a = 10; =》 会直接提升为
var a ;
a=10;
consolelog(a);

console.log(b) // 直接是报错，没有提升变量，没有定义，直接报错
let b = 1; // const同样

• 2.作用域不同：var声明变量没有块级作用域，let和const有

fun () {
  var a = 1;
  let b = 2;
  const c = 3;
}
console.log(a);  // 1
console.log(b);  // 访问不到报错
console.log(c);  // 访问不到报错

• 3.重新赋值

var a = 1;
let b = 2;
const c  = 3;

var a = 10; //ok
let b = 20; // 不可以
const c = 30; // 不可以

• 4.只声明不初始化 var、let可以，const不可以

var a; // 可
let b; // 可
const c; //不可以  定义常量

[dashengzi66]

var、 let 用来声明变量，const 声明一个只读的常量 ①let 和 const 在作用域之外不可被访问。 ②var 声明的变量会让变量声明提前，let和const的不存在。 ③在声明之前访问用var定义的变量返回undefined，let和const会直接报错 ④var 定义的变量可以重复多次声明，let 和 const 不能重复声明