一.var
含义：变量声明，无论发生在何处，都在执行任何代码之前进行处理。
注意：
1.声明变量的作用域限制在其声明位置的上下文中，而非声明变量总是全局的
function x() {
y = 1; // 在严格模式（strict mode）下会抛出ReferenceError异常。
var z = 2;
}
x();
console.log(y); // 打印"1" 。
console.log(z); // 抛出ReferenceError: z未在x外部声明。
2. 声明变量在任何代码执行前创建，而非声明变量只有在执行赋值操作的时候才会被创建。
console.log(a); // 抛出ReferenceError。console.log('still going...'); // 永不执行。
var a;
console.log(a); // 打印"undefined"或""（不同浏览器实现不同）。
console.log('still going...'); // 打印"still going..."
3. 声明变量是它所在上下文环境的不可配置属性，非声明变量是可配置的（如非声明变量可以被删除）。
var a = 1;b = 2;
delete this.a; // 在严格模式（strict mode）下抛出TypeError，其他情况下执行失败并无任何提示。
delete this.b;
console.log(a, b); // 抛出ReferenceError。// 'b'属性已经被删除。
建议：建议始终声明变量，无论它们是在函数还是全局作用域内。
参考例子：
变量提升：
var a = 2;
function foo() {
console.log(a); //undefined
var a = 10;
console.log(a); //10
}
foo();
留意其中的顺序：
var x = y, y = 'A';
console.log(x + y); // undefinedA
在这里，x和y在代码执行前就已经创建了，而赋值操作发生在创建之后。当"x = y"执行时，y已经存在，所以不抛出ReferenceError，并且它的值是'undefined'。所以x被赋予 undefined 值。然后，y被赋予'A'。于是在执行完第一行之后，x === undefined && y === 'A'才出现了这样的结果。
多个变量的初始化
var x = 0;
function f(){
var x = y = 1; // x在函数内部声明，y不是！
}
f();
console.log(x, y); // 0, 1// x是全局变量。// y是隐式声明的全局变量。
隐式全局变量和外部函数作用域
看起来像是隐式全局作用域的变量也有可能是其外部函数变量的引用。
var x = 0; // x是全局变量，并且赋值为0。
console.log(typeof z); // undefined，因为z还不存在。
function a() { // 当a被调用时，
var y = 2; // y被声明成函数a作用域的变量，然后赋值成2。
console.log(x, y); // 0 2
function b() { // 当b被调用时，
x = 3; // 全局变量x被赋值为3，不生成全局变量。
y = 4; // 已存在的外部函数的y变量被赋值为4，不生成新的全局变量。 z = 5; // 创建新的全局变量z，并且给z赋值为5。
} // (在严格模式下（strict mode）抛出ReferenceError) b(); // 调用b时创建了全局变量z。
console.log(x, y, z); // 3 4 5
}
a(); // 调用a时同时调用了b。
console.log(x, z); // 3 5
console.log(typeof y); // undefined，因为y是a函数的本地（local）变量。
二.let
含义：允许你声明一个作用域被限制在块级中的变量、语句或者表达式。与var关键字不同的是，它声明的变量只能是全局或者整个函数块的。
注意：let声明的变量只在其声明的块或子块中可用，这一点，与var相似。二者之间最主要的区别在于var声明的变量的作用域是整个封闭函数。
function varTest() {
var x = 1;
if (true) {
var x = 2; // 同样的变量!
console.log(x); // 2
}
console.log(x); // 2
}
function letTest() {
let x = 1;
if (true) {
let x = 2; // 不同的变量
console.log(x); // 2
}
console.log(x); // 1
}
作用：
1.简化内部函数代码
当用到内部函数的时候，let会让你的代码更加简洁。
var list = document.getElementById('list');
for (let i = 1; i <= 5; i++) {
let item = document.createElement('li');
item.appendChild(document.createTextNode('Item ' + i));
item.onclick = function(ev) {
console.log('Item ' + i + ' is clicked.'); };
list.appendChild(item);
}// to achieve the same effect with 'var'// you have to create a different context// using a closure to preserve the value
for (var i = 1; i <= 5; i++) {
var item = document.createElement('li');
item.appendChild(document.createTextNode('Item ' + i));
(function(i){
item.onclick = function(ev) {
console.log('Item ' + i + ' is clicked.');
};
})(i);
list.appendChild(item);
}
以上示例的工作原理是因为（匿名）内部函数的五个实例引用了变量i的五个不同实例。注意，如果你将let替换为var，则它将无法正常工作，因为所有内部函数都将返回相同的i：6的最终值。此外，我们可以通过将创建新元素的代码移动到每个循环的作用域来保持循环更清晰。
每次循环的i其实都是一个新的变量 注意for循环的作用域（父子作用域）
在程序或者函数的顶层，let并不会像var一样在全局对象上创造一个属性，比如：
var x = 'global';
let y = 'global';
console.log(this.x); // "global"
console.log(this.y); // undefined
2.模仿私有接口
在处理构造函数的时候，可以通过let绑定来共享一个或多个私有成员，而不使用闭包：
var Thing;
{
let privateScope = new WeakMap();
let counter = 0;
Thing = function() {
this.someProperty = 'foo';
privateScope.set(this, {
hidden: ++counter,
});
};
Thing.prototype.showPublic = function() {
return this.someProperty;
};
Thing.prototype.showPrivate = function() {
return privateScope.get(this).hidden;
};
}
console.log(typeof privateScope);// "undefined"
var thing = new Thing();
console.log(thing);// Thing {someProperty: "foo"}
thing.showPublic();// "foo"
thing.showPrivate();// 1
暂存死区的错误
在相同的函数或块作用域内重新声明同一个变量会引发SyntaxError。
if (x) {
let foo;
let foo; // TypeError thrown.
}
在 ECMAScript 2015 中，let绑定不受变量提升的约束，这意味着let声明不会被提升到当前执行上下文的顶部。在块中的变量初始化之前，引用它将会导致ReferenceError（而使用 var 声明变量则恰恰相反，该变量的值是 undefined ）。该变量处于从块开始到初始化处理的“暂存死区”。
function do_something() {
console.log(bar); // undefined
console.log(foo); // ReferenceError: foo is not defined
var bar = 1;
let foo = 2;
}
在switch声明中你可能会遇到这样的错误，因为它只有一个块.
switch (x) {
case 0:
let foo;
break;
case 1:
let foo; // TypeError for redeclaration.
break;
}
但是，重要的是要指出嵌套在case子句内的块将创建一个新的块作用域的词法环境，这不会产生上面显示的重新声明错误。
let x = 1;
switch(x) {
case 0: {
let foo;
break;
}
case 1: {
let foo;
break; }
}
与词法作用域结合的暂存死区
由于词法作用域，表达式(foo + 55)内的标识符“foo”会解析为if块的foo，而不是覆盖值为33的foo。在这一行中，if块的“foo”已经在词法环境中创建，但尚未达到（并终止）其初始化（这是语句本身的一部分）：它仍处于暂存死区。
function test(){
var foo = 33;
if (true) {
let foo = (foo + 55); // ReferenceError
}
}
test();
这种现象可能会使您陷入以下情况。指令let n of n.a已经在for循环块的私有范围内，因此标识符“n.a”被解析为位于指令本身的第一部分（“let n”）中的'n'对象的属性'a' ，由于尚未达成和终止其声明，因此仍处于暂存死区。
function go(n) {
// n here is defined!
console.log(n); // Object {a: [1,2,3]}
for (let n of n.a) { // ReferenceError console.log(n);
}
}
go({a: [1, 2, 3]});
一.const
含义：此声明创建一个常量，其作用域可以是全局或本地声明的块。 与var变量不同，全局常量不会变为窗口对象的属性。需要一个常数的初始化器。
注意：
// 注意: 常量在声明的时候可以使用大小写，但通常情况下全部用大写字母。
// 定义常量MY_FAV并赋值7
const MY_FAV = 7;
// 报错
MY_FAV = 20;
// 输出 7
console.log("my favorite number is: " + MY_FAV);
// 尝试重新声明会报错
const MY_FAV = 20;
// MY_FAV 保留给上面的常量，这个操作会失败
var MY_FAV = 20;
// 也会报错
let MY_FAV = 20;
// 注意块范围的性质很重要
if (MY_FAV === 7) {
// 没问题，并且创建了一个块作用域变量
MY_FAV
// (works equally well with let to declare a block scoped non const variable)
let MY_FAV = 20;
// MY_FAV 现在为 20
console.log('my favorite number is ' + MY_FAV);
// 这被提升到全局上下文并引发错误
var MY_FAV = 20;}
// MY_FAV 依旧为7
console.log("my favorite number is " + MY_FAV);
// 常量要求一个初始值
const FOO;
// SyntaxError: missing = in const declaration
// 常量可以定义成对象
const MY_OBJECT = {"key": "value"};
// 重写对象和上面一样会失败
MY_OBJECT = {"OTHER_KEY": "value"};
// 对象属性并不在保护的范围内，下面这个声明会成功执行
MY_OBJECT.key = "otherValue";// 也可以用来定义数组
const MY_ARRAY = [];
// It's possible to push items into the array
// 可以向数组填充数据
MY_ARRAY.push('A');
// ["A"]
// 但是，将一个新数组赋给变量会引发错误MY_ARRAY = ['B']
