let和const
- 不可以重复声明
- 不会发生变量提升，因此必须在声明之后使用，否则报错！
- 只在声明所在的块级作用域内有效
let
同一个作用域内不能重复声明同一个变量：
function func() { let a = 10; var a = 1; } func() // 报错 function func() { let a = 10; let a = 1; } func() // 报错
function func(arg) { let arg; } func() // 不能在函数内部重新声明参数！！！！！因为参数等同于在函数内部var声明的一个局部变量 function func(arg) { { let arg; } } func() // 该例子不报错，是因为在func里面增加{}等同于又新建了一个作用域，因此{}里的arg不是参数arg
let可以只声明不赋值，没有值的时候会输出undefined
console.log(let1) // let1 is not defined let let1; console.log(let1) // undefined let1 = 1; console.log(let1) // 1
let在for循环中的应用：【下面将给出我对这两个例子的理解】
var a = []; for (var i = 0; i < 10; i++) { a[i] = function () { console.log(i); }; } a[6](); // 10
该demo的执行过程如下：
var a = []; // 全局变量
var i = 0; // 全局变量，第1次循环
a[0] = function(){ console.log(i) } // 此时的i不是0，是因为这里只是声明了这个函数，并没有执行它，即没有创建这个函数的上下文，因此i不会沿着作用域链向外去找i的值
var i = 1; // 第2次循环，因为是全局变量，因此i = 1会替换上一个i = 0
a[1] = function(){ console.log(i) } // 同a[0]，所有该函数的执行的作用域是全局作用域
var i = 2 // 第3次循环，同理，i = 2会替换上一个i = 1
...
var i = 9; // 第10次循环，i = 9会替换上一个i = 8
a[9] = function(){ console.log(i) }
直到var i = 10，10<10不满足循环条件，则跳出循环，继续向下执行全局作用域下面的语句：a[6]();
调用a[6]函数，并创建a[6]函数的函数上下文，执行该函数内部的console.log(i)，这个函数中没有i，因此顺着作用域链向外去找i，而此时全局变量var i = 10，因此输出10
var a = []; for (let i = 0; i < 10; i++) { a[i] = function () { console.log(i); }; } a[6](); // 6
第二个demo的执行过程如下：
let a = []; // 全局变量
{ // 第1次循环
let i = 0; // let使得for循环变成一个块级作用域，则let i = 0是这个块级作用域下的局部变量
a[0] = function(){ console.log(i) } // 注意！！！由于let的声明创建了一个块级作用域，此时的a[0]这个函数就是一个闭包
}
{ // 第2次循环
let i = 1; // 注意！！！此时的let i = 1和let i = 0是属于两个不同的块级作用域，因此两者的值并不会相互影响
a[1] = function(){ console.log(i) } // 同a[0]
}
...
{ // 第10次循环
let i = 9;
a[9] = function(){ console.log(i) } // 同样该函数也是一个闭包！
}
{
直到let i = 10，不满足循环条件，跳出循环，注意！！该代码块中不存在闭包因此，let i = 10在这次循环之后代码块随即被销毁
}
继续向下执行全局作用域下面的语句：a[6]();
调用a[6]函数，进入该块级作用域的代码环境，在该闭包内部找i值，如果没有则顺着作用域链向外去找i，而此时块级作用域内有let i = 6，因此输出6
此时闭包被调用，所以整个代码块中的变量i和a[6]函数被销毁。
暂时性死区
在代码块内，凡是用let声明变量之前，该变量都是不可使用的，这在语法上叫做“暂时性死区”（Temporal Dead Zone，简称TDZ）。所以，凡是在声明之前使用该变量，就会报错！
var tmp = 'ning'; if (true) { // TDZ开始 tmp = 'abc'; // ReferenceError console.log(tmp); // ReferenceError 去掉这两句才能继续向下执行代码并输出响应的结果 let tmp; // TDZ结束 console.log(tmp); // undefined tmp = 123; console.log(tmp); // 123 }
从上面的代码可以看出虽然全局有一个tmp变量，但是在if这个块级作用域下let声明了一个局部变量tmp，导致该局部变量tmp绑定（binding）了这个区域，所以在let声明之前使用它，都属于该tmp的死区，会报错！
在没有let之前，使用typeof是百分之百不会报错的，因为如果typeof一个未声明的变量，会输出'undefined'
但是，暂时性死区的出现使得typeof的使用需要小心！因为如果在let声明前typeof该变量则会报错！
typeof x; // ReferenceError let x;
const
const声明一个只读的常量。一旦声明其值就不能改变，并且一旦声明变量就必须立即初始化，只声明不赋值就会报错！
console.log(const1) // Missing initializer in const declaration const const1; console.log(const1) // Missing initializer in const declaration
cosnt也是在块级作用域内有效，例子如下：
if (true) { const MAX = 5; } console.log(MAX); // Uncaught ReferenceError: MAX is not defined
const命令声明的常量不能提升，只能在声明的位置之后使用const，例子如下：
if (true) { console.log(MAX); // Uncaught ReferenceError: MAX is not defined const MAX = 5; }
const同样不能重复声明！例子如下：
function func() { const a = 10; var a = 1; } func() // 报错 function func() { const a = 10; let a = 1; } func() // 报错
const的本质：
实际上是保证的是变量指向的内存地址保存的数据不能改动！
对于基本数据类型而言，内存地址里保存的就是值，所以等同于常量
而对于引用类型而言（主要是对象和数组），变量指向的内存地址中保存的是 指向实际数据的指针，因此只要该指针是固定不变的，该指针指向的堆内存的数据是否变化const是不在意的！因此，将一个对象声明为常量必须非常小心！！！！例子如下：
const obj = {}; obj.attr = 'ning'; console.log(obj.attr) // 'ning' obj = { attr: 'li' } console.log(obj.attr) // Uncaught TypeError: Assignment to constant variable.
常量obj存的是一个地址，指向一个对象，不可变的是这个地址，而对象本身里的内容是可变的！
