ES6中var let const三种变量(一文弄清楚)

ES6中三种变量声明

  ECMAScript 变量是松散类型的，变量可以用于保存任何类型的数据。有3个关键字可以声明变量：var、const 和 let。其中，var在ECMAScript 的所有版本中都可以使用，而 const 和 let 只能在 ECMAScript6 及更晚的版本中使用。

3.1 var 关键字

  使用 var 操作符(注意var是一个关键字)，后跟变量名，可以同时定义变量并设置它的值。例如：

var a;
var b = "hi";
b = 100;	// 合法，但不推荐

1. var 声明作用域

  使用 var 操作符定义的变量会成为包含它的函数的局部变量。该变量将在函数退出时被销毁。

function test() {
	var message = "hi"; 	// 局部变量
}
test();
console.log(message);		// 出错

  在函数内定义变量时省略 var 操作符，可以创建一个全局变量：只要调用一次函数test()，就会定义这个变量，并且可以在函数外部访问到。

function test() {
	message = "hi"; 		// 全局变量
}
test();						// 如果没调用则不会定义这个变量
console.log(message); 		// "hi"

  注意：虽然可以通过省略 var 操作符定义全局变量，但不推荐这么做。在局部作用域中定义的全局变量很难维护，也会造成困惑。在严格模式下，如果像这样给未声明的变量赋值，则会导致抛出 ReferenceError。

"use strict";
function fu(){
   na = "andy";
}
console.log(na);	// ReferenceError: na is not defined

  如果需要定义多个变量，可以在一条语句中用逗号分隔每个变量(及可选的初始化)：如下，每个变量都相当于用 var 声明的。

var message = "hi",
	found = true,
	age = 27;

  在严格模式下，不能定义名为 eval 和 arguments 的变量，否则会导致语法错误。

2. var 声明提升

  使用 var 时，下面的代码不会报错。这是因为使用这个关键字声明的变量会自动提升到函数作用域顶部:

function foo() {
  console.log(age);
  var age = 26;
}
foo();	// undefined
// 上述代码等价于：
function foo(){
	var age;
    console.log(age);
    age = 26;
}
foo();

  这就是所谓的“提升”，把所有变量声明都拉到函数作用域的顶部。此外，反复多次使用 var 声明同一个变量也没有问题：

function foo() {
  var age = 16;
  var age = 26;
  var age = 36;
  console.log(age);
}
foo(); // 36

3.2 let 声明

  let 跟 var 的区别①是，let 声明的范围是块作用域，而 var 声明的范围是函数作用域。

if (true) {
   var name = 'Matt';
   console.log(name); // Matt
 }
 console.log(name);   // Matt

if (true) {
   let age = 26;		// let 声明的变量 age 在 if 块内部才能用
   console.log(age);   // 26
}
console.log(age); 	// ReferenceError: age没有定义

  let 也不允许同一个块作用域中出现冗余声明。这样会导致报错。混用let 和 var 声明同名变量也会报错。

var name;
var name;

let age;
let age; 	// SyntaxError;标识符age已经声明过了

let a;
var a;		// SyntaxError
var b;
let b;		// SyntaxError

1. 暂时性死区

  let 声明的变量与 var 的另一个重要区别②是 let 声明的变量不会在作用域中被提升。

// name 会被提升 
console.log(name); // undefined 
var name = 'Matt';
// age 不会被提升
console.log(age); // ReferenceError:age没有定义 
let age = 26;

  在解析代码时，JavaScript 引擎也会注意出现在块后面的 let 声明， 只不过在此之前不能以任何方式来引用未声明的变量。在 let 声明之前的执行瞬间被称为“暂时性死区”，在此阶段引用任何后面才声明的变量都会抛出 ReferenceError。

2. 全局声明

  使用 let 在全局作用域中声明的变量不会成为 window 对象的属性( var 声明的全局变量则会成为 window 对象的属性)。

var name = 'Matt';
console.log(window.name); // 'Matt'
let age = 26;
console.log(window.age);  // undefined

3. 条件声明

  在使用 var 声明变量时，由于声明会被提升，JavaScript 引擎会自动将多余的声明在作用域顶部合并为一个声明。因为 let 的作用域是 块，所以不可能检查前面是否已经使用 let 声明过同名变量，同时也就不可能在没有声明的情况下声明它。

<script>
	var name = 'Nicholas';
	let age = 26;
</script>

<script>
    // 假设脚本不确定页面中是否已经声明了同名变量 
    // 那它可以假设还没有声明过
    var name = 'Matt';
    // 这里没问题，因为可以被作为一个提升声明来处理 
    // 不需要检查之前是否声明过同名变量
    let age = 36;
    // 如果age之前声明过，这里会报错 
</script>

  let 声明变量不能检测之前有没有声明过同名的变量问题也不能用 try/catch 语句或 typeof 操作符解决，就是因为 let 声明的作用域仅限于块作用域。

<script>
  let name = 'Nicholas';
  let age = 36;
</script>

<script>
	// 假设脚本不确定页面中是否已经声明了同名变量 
	// 那它可以假设还没有声明过
  	if (typeof name === 'undefined') {
    	let name;		// name被限制在if {} 块的作用域内
	} 
	name = 'Matt';		// 因此这个赋值形同全局赋值
	try (age) {			// 如果age没有声明过，则会报错
  	}catch(error) {
		let age; }		// age被限制在catch {}块的作用域内
	age = 26;			// 因此这个赋值形同全局赋值
</script>

  因此，let 这个新的 ES6 声明变量的关键字不能依赖条件声明模式。

4. for 循环中的 let 声明

  在 let 出现之前，for 循环定义的迭代变量会渗透到循环体外部，使用 let 后这个问题就消失了，因为let 声明的迭代变量作用域仅限于 for 循环块内部。

for (var i = 0; i < 5; i++){
    // 循环体
}
console.log(i);	// 5

for (let t = 0; t < 5; t++){
	// 循环体
}
console.log(t);	// ReferenceError: t is not defined

  使用 var 声明迭代变量还会遇到下面问题

for(var i = 0;i<5;i++){
    setTimeout(()=>console.log(i),0);
}
// 你可能以为会输出0、1、2、3、4 
// 实际上会输出5、5、5、5、5

  之所以会这样，是因为在退出循环时，迭代变量保存的是导致循环退出的值：5。在之后执行超时逻辑（setTimeout()函数） （JS执行机制3个介绍视频）时，所有的i都是同一个变量， 因而输出的都是同一个最终值。

  而在使用 let 声明迭代变量时，JavaScript 引擎在后台会为每个迭代循环声明一个新的迭代变量。每个 setTimeout 引用的都是不同的变量实例，所以 console.log 输出的是我们期望的值，也就是循环执行过程中每个迭代变量的值。

for (let i = 0; i < 5; ++i) {
    setTimeout(() => console.log(i), 0)
}
// 会输出0、1、2、3、4

  这种每次迭代声明一个独立变量实例的行为适用于所有风格的 for 循环，包括 for-in 和 for-of 循环。

3.3 const 声明

  const 的行为与let 基本相同，区别是用它声明变量时必须同时初始化变量，且不能修改const 声明的变量否则会导致运行时错误。

const age = 26;
age = 36; 		// 【报错】 TypeError: 给常量赋值	

// const也不允许重复声明
const name = 'Matt';
const name = 'Nicholas'; 	// 【报错】SyntaxError

// const声明的作用域也是块 
const pet = 'dog';
if (true) {
  const pet = 'cat';	
}
console.log(pet); // dog

  const 声明的限制只适用于它指向的变量的引用。如果const 变量引用的是一个对象，那么修改这个对象内部的属性并不违反const 的限制。

const person = {};
person.name = 'Matt';  // ok

  不能用const来声明迭代变量(因为迭代变量会自增):

for (const i = 0; i < 10; ++i) {} // TypeError:给常量赋值

  用const声明一个不会被修改的for循环变量，是可以的。也就是说，每次迭代只是创建一个新变量。这对for-of 和for- in 循环特别有意义:

let i = 0;
for (const j = 7; i < 5; ++i) {
  console.log(j);
}
// 7, 7, 7, 7, 7
for (const key in {a: 1, b: 2}) {
  console.log(key);
}
// a, b
for (const value of [1,2,3,4,5]) {
  console.log(value);
}
// 1, 2, 3, 4, 5

3.4 声明风格及最佳实践

  ECMAScript 6增加let和const从客观上为这门语言更精确地声明作用域 和语义提供了更好的支持。

• 不使用 var ：有了 let 和 const，不再需要var了。只使用 let 和const 有助于提升代码质量，因为变量有了明确的作用域、声明位置，以及不变的值。
• const 优先，let 次之：使用const声明可以让浏览器运行时强制保持变量不变，也可以让静态代码分析工具提前发现不合法的赋值操作。只在提前知道未来会有修改时，再使用let。

3.5 总结

• var

1. 在函数内部声明的变量为函数的局部变量(函数作用域)，如果省略var且在非严格模式下，且调用了函数，则创建的是全局变量；

2. var的声明会提升到作用域的顶部

3. 可以重复声明同一个变量

4. 全局作用域下声明的变量会成为window的属性

5. for 循环定义中用var声明的迭代变量会渗透到循环体外部

• let

1. 声明的范围是块作用域

2. 不能声明同名变量，也不能跟var一起声明同名变量

3. let声明没有提升，会出现暂时性死区（定义前使用变量名）

4. 全局作用域下声明的变量不会成为window的属性

5. let 声明变量不能检测之前有没有声明过同名的变量，let关键字不能依赖条件声明模式。

6. for 循环定义中用let声明的迭代变量不会渗透到循环体外部

7. 使用 let 声明迭代变量时，JavaScript 引擎在后台会为每个迭代循环声明一个新的迭代变量。

• const

1. const声明变量时必须同时初始化变量

2. 不能修改const 声明的变量