1. EcmaScript 5作用域
EcmaScript5的作用域有全局作用域(global scope)与函数作用域（function scope）两种。
1.1 全局作用域
在全局作用域中定义的变量，在整个上下文中都是可以访问的。
var msg = 'Hello world';
console.log(msg); // Hello world
function sayHi(){
console.log(msg);// Hello world
}
sayHi();
上面例子中msg在sayHi()函数内外都可以访问。
在NodeJs中，在js文件中直接使用var关键字声明的变量，将会在模块上声明。
在浏览器中，在script标签中直接使用var关键字声明的变量，将定义在全局变量window上，window对象中的属性拥有全局作用域。
在严格模式(strict mode)下，变量在初始化前必须声明，否则会抛出
ReferenceError
'use strict';
a = 2;
console.log(a); // Uncaught ReferenceError: a is not defined
在非严格模式下，使用未声明的变量将隐式声明为全局变量，定义在window上
a = 2;
console.log(a); // 2
console.log(a === window.a) // true
1.2 函数作用域
在函数作用域中定义的变量，只能在函数中被访问
function fn(){
var a = 1;
console.log(a); // 1
}
console.log(a); // Uncaught ReferenceError: a is not defined
2. 声明提升
声明提升（hoisting）指通过var关键字声明的变量，将提升到函数（或者全局作用域）的顶部进行声明，与声明语句的实际位置无关。
function sayHi(condition){
if(condition){
var msg = 'Hello world';
console.log(msg); // Hello world
}else{
console.log(msg); // undefined
}
}
sayHi(true);
sayHi(false);
上面例子中msg在if语句中进行了声明和初始化赋值，但实际上msg将“提升”到函数顶部进行声明，而赋值的位置不变，还在if语句中。因此在else语句中同样可以访问msg变量，其值为undefined。Javascript引擎会将上面的代码处理成类似下面的样子。
function sayHi(condition){
var msg；
if(condition){
msg = 'Hello world';
console.log(msg); // Hello world
}else{
console.log(msg); // undefined
}
}
sayHi(true);
sayHi(false);
3. 块级作用域声明
EcmaScript 6引入了块级作用域(block scope)，块级作用域只能在块中被访问，以下两种情况可以创建块级作用域的变量。
- 在函数中
- 在被
{和}包裹的块中
3.1 let声明
let关键字的作用类似var，用来声明变量，不同的是其声明的变量具有块级作用域。
'use strict';
function sayHi(condition){
if(condition){
let msg = 'Hello world';
console.log(msg); // Hello world
}else{
console.log(msg); // ReferenceError: msg is not defined
}
}
sayHi(true);
sayHi(false);
如上面例子，msg只能在if语句块中被访问，在else中访问会产生ReferenceError错误
3.2 不能重复声明
使用var关键字声明的变量，在同一个作用域可以重复进行声明，后面的将会覆盖前面的。而使用let关键字声明的变量，在同一个作用域不能重复声明（不管之前是用var，let， 或者const声明），否则将会触发SyntaxError错误。
'use strict';
var a = 1;
var a = 2;
//var b = 1;
//let b = 2; // SyntaxError: Identifier 'b' has already been declared
//let c = 1;
//let c = 2; // SyntaxError: Identifier 'c' has already been declared
const d = 1;
let d = 2; // SyntaxError: Identifier 'd' has already been declared
在变量包含的作用域是用let关键字声明的变量，不会生成错误。如下面代码，在if语句中，新的变量a将覆盖外面的变量a。
'use strict';
let a = 1;
if(true){
let a = 2;
console.log(a); // 2
}
console.log(a); // 1
3.3 const声明
使用const关键字声明的变量将作为常量使用，一旦被赋值，将不能再被改变，因此const关键字声明的变量必须同时进行初始化，否则会抛出SyntaxError错误
'use strict';
const maxItems = 30;
const name; // SyntaxError: Unexpected token
上面例子中的name变量没有进行初始化，因此将触发SyntaxError。
const关键字与let关键字相同的地方
- 声明的变量具有块级作用域。
- 在相同的作用域，重复声明变量将会抛出
SyntaxError错误
const关键字与let关键字不同的地方
-
const声明的变量不能重复进行赋值， 否则将抛出TypeError错误
const声明的对象不能改变，但是对象中的属性可以进行改变。const绑定的是对象的引用，对象中实际的值是可以改变的。
'use strict';
const person = {
name:'Mary'
};
person.name = 'Jim';
person = {
name:'Bary'
}; // TypeError: Assignment to constant variable
3.4 临时死区
使用let和const声明的变量，只有在声明之后才能够使用，否则会触发ReferenceError错误，即使在ES5中可以安全使用的typeof关键字在ES6中也不能保证可以安全使用。这种特殊行为就叫做临时死区(Temporal Death Zone)。
'use strict';
if(true){
console.log(typeof value); // ReferenceError: value is not defined
const value = 'blue';
}
如上面代码，由于临时死区的存在，value变量在声明之前是不能被访问的。
当Javascript引擎遇到一个代码块并且代码块中存在变量声明，那么要么进行变量声明提升（hoisting），将变量提升到函数或者全局作用域顶部进行声明（使用var关键字）；要么将变量放入临时性死区（使用const或者let关键字），尝试访问临时性死区中的变量将会导致ReferenceError错误。在遇到变量声明（const或者let关键字）后，该变量将被移出临时性死区，变量就可以被访问了。
'use strict';
console.log(typeof value); // undefined
if(true){
let value = 'blue';
}
如上面代码，value变量并未放入临时性死区，使用typeof关键字仍然是安全的。
4. 循环
4.1 循环的块级作用域
实际开发中比较长使用的是在循环中使用块级作用域，在Javascript中，var关键字在循环中使用有着很多不被其他语言开发者了解的缺陷。
for(var i=0;i<10;i++){
// do something
}
console.log(i); // 10
例如上面代码中，开发者希望达到的效果是i在循环之后不能访问，但是由于Javascript会进行变量声明“提升”，i在循环结束之后，仍然能够访问。
使用let关键字，可以有效避免这个问题。
for(let i=0;i<10;i++){
// do something
}
console.log(i); // ReferenceError
4.2 函数的循环
使用var关键字创建的变量在循环内部的函数中使用有一些问题。例如下面的代码，开发者期待输出从0到9，但是由于i在循环之后仍然能够访问，funcs中的每个函数引用的是同一个i，因此在调用后输出了十次10。
var funcs = [];
for(var i = 0;i < 10;i++){
funcs.push(function(){console.log(i);});
}
funcs.forEach(function(func){
func(); // / outputs 10 ten times
});
上面的问题可以通过立即执行函数(Immidiately Invoked Function Expressions，IIFEs)来解决
var funcs = [];
for(var i = 0;i < 10;i++){
funcs.push((function(val){
return function(){console.log(val);};
})(i));
}
funcs.forEach(function(func){
func(); // outputs 0, then 1, then 2, up to 9
});
如上面的代码，使用立即执行函数强制将i作为参数传入到每个函数中，这样每个函数保存的是循环过程中i的副本，因此可以正确输出。
4.3 在循环中使用let
使用let关键字可以用比较简单清晰的代码解决上面的问题。
'use strict';
var funcs = [];
for(let i = 0;i < 10;i++){
funcs.push(function(){console.log(i);});
}
funcs.forEach(function(func){
func(); // outputs 0, then 1, then 2, up to 9
});
如上面代码，使用let会在每次循环过程中，创建一个新的变量i，因此每个函数读取到的是每次循环的i的副本，每个i的副本的值由循环初始化时i的值决定。
在for in和for of循环中，let关键字有同样的特性。如下面代码，在每次循环时创建一个新key绑定，这样每次循环都一个新的key变量，因此每个函数输出不同的key。如果使用var关键字代替let，那么所有函数将输出相同的值c。
var funcs = [],
object = {
a: true,
b: true,
c: true
};
for (let key in object) {
funcs.push(function() {
console.log(key);
});
}
funcs.forEach(function(func) {
func(); // outputs "a", then "b", then "c"
});
注意：let关键字在循环中的特性在规范中定义，但是跟let关键字的“非提升”特性并不相关。实际上，早起的一些let实现并没有实现上述在循环中的特性。这些特性是逐渐添加的。
4.4 在循环中使用const
EcmaScript 6规范并没有在循环中使用const给予禁止，但是在不同的循环类型（for, for in, for of），其行为是不同的。在for循环中，const可以在循环初始化时使用，但是如果尝试修改其值，那么将会抛出错误。如下面代码，i在初始化时时没问题的，但是在调用i++时，将会发生TypeError错误，因为++操作尝试修改一个常量的值。
'use strict';
var funcs = [];
for(const i=0;i<10;i++){ // TypeError: Assignment to constant variable
funcs.push(function(){
console.log(i);
});
}
在for in, for of循环中使用const关键字则不会发生错误
'use strict';
var funcs = [],
object = {
a: true,
b: true,
c: true
};
// doesn't cause an error
for (const key in object) {
funcs.push(function() {
console.log(key);
});
}
funcs.forEach(function(func) {
func(); // outputs "a", then "b", then "c"
});
如上面代码，使用const关键字与let关键字的不同之处只在于，key变量在块中不能被修改。由于在for in, for of循环中，每次遍历都会绑定一个新的key而不是尝试修改原来的key，因此const关键字在for in, for of中使用是没问题的。
4.5 全局作用域
在全局作用域使用let或者const关键字与var是不同的。当在全局作用域使用var关键字时，创建一个新的全局变量，并将其绑定到全局对象的属性上。因此，可以使用var覆盖全局对象上已经存在的变量。
// in a browser
var RegExp = "Hello!";
console.log(window.RegExp); // "Hello!"
var ncz = "Hi!";
console.log(window.ncz); // "Hi!"
上面的代码中，window对象原有的RegExp被修改，ncz被定义为一个全局变量，并写入全局对象的属性上。
let与const关键字会创建在全局作用域创建一个变量，但是并不会写入到全局对象的属性。因此，let与const关键字创建的变量不会覆盖全局变量，而只能创建一个优先读取的“影子”变量。
// in a browser
let RegExp = "Hello!";
console.log(RegExp); // "Hello!"
console.log(window.RegExp === RegExp); // false
const ncz = "Hi!";
console.log(ncz); // "Hi!"
console.log("ncz" in window); // false
如上面代码，RegExp与window.RegExp是不同的，ncz也并不在window对象上。因此，当开发者不需要在全局对象上创建变量，使用let和const关键字在全局作用域创建对象相比var是安全的。
5. 现有的最佳实践
由于let关键字的特性更符合其他语言的习惯，不会产生var关键字导致的各种问题，因此尽量使用let关键字广被开发者倡导。
由于大部分变量实际上不会改变，而修改变量会导致不可测的bug，因此对于那些不会发生改变的变量，要使用const关键字
