var、let和const变量使用方法和注意事项

var关键字

1.var声明作用域
使用var操作符定义的变量会成为包含它的函数的局部变量。比如，使用var在一个函数内部定义一个变量，就意味着该变量将在函数退出时被销毁：

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

这里，message变量是在函数内部使用var定义的。函数叫test()，调用它会创建这个变量并给它赋值。调用之后变量随即被销毁，因此示例中的最后一行会导致错误。不过，在函数内部定义变量的时候省略var操作符，可以创建一个全局变量：

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

去掉之前的var操作符之后，message就变成了全局变量。只要调用一次函数test()，就会定义这个变量，并且可以在函数外部访问到。

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

如果需要定义多个变量，可以在一条语句中用逗号分隔每个变量（及可选的初始化）：

var message = "hi",
	  found = false,
	  age = 29;

这里定义并初始化了3个变量。因为ECMAScript是松散类型的，所以使用不同数据类型初始化的变量可以用一条语句来声明。插入换行和空格缩进并不是必须的，但是这样有利于阅读理解。

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

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

之所以不会报错，是因为ECMAScript运行时把它看成等价于如下代码：

function foo(){
	var age；
	console.log(age);
	age = 26;
}
foo();  //undefined

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

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

let关键字

1.let声明
let跟var的作用差不多，但是有着非常重要的区别。最明显的区别是，let声明的范围是块作用域，而var声明的范围是函数作用域。

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

if (true) {
	let age= 26;
	console.log(age); //26
}
console.log(age); //ReferenceError:age没有定义

在这里，age变量 之所以不能在if块外部被引用，是因为它的作用域仅限于该块内部。块作用域是函数作用域的子集，因此适用于var的作用域限制同样也适用于let。

let也不允许同一个块作用域中出现冗余声明。这样会导致报错：

var name;
var name;

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

当然，JavaScript引擎会记录用于变量声明的标识符及其所在的块作用域，因此嵌套使用相同的标识符不会报错，而这是因为同一个块中没有重复声明：

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

let age= 30;
console.log(age); //30
if (true){
	let age= 26;
	console.log(age); // 26
}

对声明冗余报错不会因为混用let和var而受影响。这两个关键字声明的并不是不同类型的变量，它们只是指出变量在相关作用域如何存在。

var name;
let name;// SyntaxError

let age;
var age;// SyntaxError

2.暂时性死区
let与var的另一个重要的区别，就是let声明的变量不会在作用域中被提升。

//name会被提升
console.log(name); // undefined
var name = "Matt";

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

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

3.全局声明
与var关键字不同，使用let在全局作用域中声明的变量不会成为window对象的属性（var声明的变量则会）。

var name = "Matt";
console.log(window.name); // "Matt"

let age = 26;
console.log(window.age); // undefined

不过，let声明仍然是在全局作用域中发生的，相应变量会在页面的生命周期内存续。因此，为了避免SyntaxError，必须确保页面不会重复声明同一个变量。

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

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

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

使用try/catch语句或typeof操作符也不能解决，因为条件块中let声明的作用域仅限于该块。

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

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

5.for循环中的let声明
在let出现之前，for循环定义的迭代变量会渗透到循环体外部：

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

改成使用let之后，这个问题就消失了，因为迭代变量的作用域仅限于for循环块内部：

for (let i = 0; i < 5; ++i){
	//循环逻辑
}
console.log(i); // ReferenceError：i没有定义

在使用var的时候，最常见的问题就是对迭代变量的奇特声明和修改：

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

之所以会这样，是因为在退出循环时，迭代变量保存的是导致循环退出的值5。在之后执行超时逻辑时，所有的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循环。

const关键字

1.const声明
const的行为与let基本相同，唯一一个重要的区别是用它声明变量时必须同时初始化变量，且尝试修改const声明的变量会导致运行时错误。

const age = 26;
age = 36; // TypeError:给常量赋值

//const 也不允许重复声明
const name = "Matt";
const name = "Nicholas"; // SyntaxError

//const声明的作用域也是块
const name = "Matt";
if (true){
	const name = "Nicholas";
}
console.log(name); //Matt

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

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

JavaScript引擎会为for循环中的let声明分别创建独立的变量实例，虽然const变量跟let变量很相似，但是不能用const来声明迭代变量（因为迭代变量会自增）：

for (const i = 0; i < 5; ++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

声明风格及最佳实践

1.不使用var
有了let和const，大多数开发者会发现自己不再需要var了。限制自己只使用let和const有助于提升代码质量，因为变量有了明确的作用域、声明位置，以及不变的值。
2.const优先，let次之
使用const声明可以让浏览器运行时强制保持变量不变，也可以让静态代码分析工具提前发现不合法的赋值操作。因此，很多开发者认为应该优先使用const来声明变量，只在提前知道未来会有修改时，再使用let。这样可以让开发者更有信心地推断某些变量的值永远不会变，同时也能迅速发现因意外赋值导致的非预期行为。