es6语法入门let 和 const 命令

let块级作用域

 {
   let a = 10;
   var b = 1;
 }

 a // ReferenceError: a is not defined.
 b //

for循环的计数器，就很合适使用let命令（防止i泄露为全局变量）

 for (let i = 0; i < 10; i++) {
   // ...
 }

 console.log(i);
 // ReferenceError: i is not defined

下面的代码如果使用var，最后输出的是10。

 var a = [];
 for (var i = 0; i < 10; i++) {
   a[i] = function () {
     console.log(i);
   };
 }
 a[6](); //

如果使用let，声明的变量仅在块级作用域内有效，最后输出的是6。

 var a = [];
 for (let i = 0; i < 10; i++) {
   a[i] = function () {
     console.log(i);
   };
 }
 a[6](); //

如果是es5也想输出6的话,必须使用闭包

 var a = [];
 for (var i = 0; i < 10; i++) {
   (function(i){
     a[i]=function(){
       console.log(i)
     }
   })(i)
 }
 a[6](); //

for循环还有一个特别之处，就是设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域

 for (let i = 0; i < 3; i++) {
   let i = 'abc';
   console.log(i);
 }
 // abc
 // abc
 // abc

 // var 的情况
 console.log(foo); // 输出undefined
 var foo = 2;

 // let 的情况
 console.log(bar); // 报错ReferenceError
 let bar = 2;

不存在变量提升,如上图

 var tmp = 123;

 if (true) {
   tmp = 'abc'; // ReferenceError
   let tmp;
 }

存在全局变量tmp，但是块级作用域内let又声明了一个局部变量tmp，导致后者绑定这个块级作用域，所以在let声明变量前，对tmp赋值会报错

 if (true) {
   // TDZ开始
   tmp = 'abc'; // ReferenceError
   console.log(tmp); // ReferenceError

   let tmp; // TDZ结束
   console.log(tmp); // undefined

   tmp = 123;
   console.log(tmp); //
 }

 typeof x; // ReferenceError
 let x;

如果一个变量没有声明，使用typeof不会报错

 typeof undeclared_variable // "undefined"

 function bar(x = y, y = 2) {
   return [x, y];
 }

 bar(); // 报错

 function bar(x = 2, y = x) {
   return [x, y];
 }
 bar(); // [2, 2]

// 不报错
var x = x;

// 报错
let x = x;
// ReferenceError: x is not defined

LET不允许相同作用域重复声明

 // 报错
 function () {
   let a = 10;
   var a = 1;
 }

 // 报错
 function () {
   let a = 10;
   let a = 1;
 }

 function func(arg) {
   let arg; // 报错
 }

 function func(arg) {
   {
     let arg; // 不报错
   }
 }

内层变量可能覆盖外层变量

 var tmp = new Date();

 function f() {
   console.log(tmp);
   if (false) {
     var tmp = 'hello world';
   }
 }

 f(); // undefined

 // 浏览器的 ES6 环境
 function f() { console.log('I am outside!'); }

 (function () {
   if (false) {
     // 重复声明一次函数f
     function f() { console.log('I am inside!'); }
   }

   f();
 }());
 // Uncaught TypeError: f is not a function

等价于

 // 浏览器的 ES6 环境
 function f() { console.log('I am outside!'); }
 (function () {
   var f = undefined;
   if (false) {
     function f() { console.log('I am inside!'); }
   }

   f();
 }());
 // Uncaught TypeError: f is not a function

CONST

 const foo = {};

 // 为 foo 添加一个属性，可以成功
 foo.prop = 123;
 foo.prop //

 // 将 foo 指向另一个对象，就会报错
 foo = {}; // TypeError: "foo" is read-only

 const a = [];
 a.push('Hello'); // 可执行
 a.length = 0;    // 可执行
 a = ['Dave'];    // 报错