1     "use strict";
2          /*如果不加"use strict";会报错:Uncaught SyntaxError: Block-scoped declarations (let, const, function, class) not yet supported outside strict mode*/
3         {
4
5             let a=10;//let 声明变量,只在let命令所在的代码块内有效。
6             var b=66;
7         }
8         alert(b);
9         alert(a);//Uncaught ReferenceError: a is not defined

 1 for //循环计数器，很适合使用let命令。
 2
 3         for(let i=0;i<10;i++){
 4             //...
 5         }
 6         console.log(i);//Uncaught ReferenceError: i is not defined
 7         //上面代码中，计数器i只在for循环体内有效，在循环体外引用就会报错。
 8
 9         var a=[];
10         //变量i时var声明的，在全局范围内有效，每次循环，变量i的值都会发生改变，而循环内被赋给数组a的函数内部的console.log(i),这里的i指向的就是全局的i，所有数组a的成员里面的i，指向的都是同一个i，导致运行时输出的是最后一轮i的值，也就是10.
11         for(var i=0;i<10;i++){
12             a[i]=function(){
13                 console.log(i);
14             };
15         }
16         a[6]();
17
18
19
20         var a=[];
21         for(let i=0;i<10;i++){
22             // 变量i是用let声明的，当前的i只在本轮循环有效，所有每一次循环的i其实都是一个新的变量，所有最后输出是6.每轮循环的变量的i都是重新声明的，JavaScript引擎内部会记住上一轮循环的值，初始化本轮的变量i时，就是上一轮循环的基础上进行计算。
23             a[i]=function(){
24                 console.log(i);
25             };
26         }
27         a[6]();//6
28
29
30         //for循环的特别之处，设置循环变量的那一部分是一个父作用域，而循环体内部是一个单独的子作用域。
31         for(let i=0;i<3;i++){
32             let i='abc';
33             console.log(i);//输出三次abc。这表明函数内部的变量i与循环体变量i不在同一个作用域，有各自单独的作用域。
34         }

 1 console.log(foo);//undefined
 2         var foo=2;
 3
 4         console.log(foo);
 5         let foo=2;//Uncaught ReferenceError: foo is not defined
 6
 7         //暂时性死区：在代码块内，使用let命令声明变量之前，该变量都是不可用的，这在语法上，成为“暂时性死区（temporal dead zone，TDZ）”,暂时性死区的本质就是，只要一进入当前作用域，所要使用的变量就已经存在了，但是不可获取，只有等到声明变量的那一行出现，才可以获取和使用该变量。
 8
 9         //只要块级作用域内存在let命令，它所声明的变量就"绑定"这个区域，不再受外部的影响。
10         var tmp=123;
11         if(true){
12             tmp='abc';
13             let tmp;//Uncaught ReferenceError: tmp is not defined,ES6明确规定，如果在区块中存在let和const命令，这个区块对这些命令声明的变量从一开始就形成了封闭作用域。凡是在声明之前就使用这些变量，就会报错。
14         }
15
16         if (true) {
17               // TDZ开始
18               tmp = 'abc'; // ReferenceError
19               console.log(tmp); // ReferenceError
20
21               let tmp; // TDZ结束
22               console.log(tmp); // undefined
23
24               tmp = 123;
25               console.log(tmp); // 123
26             }
27
28         //较隐蔽的暂时性死区。
29         function bar(y = x, x = 2 ) {
30           return [x, y];
31         }
32         bar(); // es6.html:89 Uncaught ReferenceError: x is not defined
33         console.log(bar());
34
35         function bar(x=2,y=x){
36             return [x,y];
37         }
38         bar();
39         console.log(bar());//[2, 2]
40
41         var x=x;//不报错
42
43         let x=x;//es6.html:103 Uncaught ReferenceError: x is not defined

 1     //let不允许在相同作用域内，重复声明同一个变量
 2         //因此，不能再函数内部重新声明参数。
 3
 4         //报错
 5         function(){
 6             let a=10;
 7             var a=1;
 8         }
 9
10         // 报错
11         function(){
12             let a=10;
13             let a=1;
14         }
15
16         function func(arg){
17             let arg;//报错,identifier top has already been declared标识符顶部已被声明
18         }
19         func(4);
20
21         function func(arg){
22             {
23                 let arg;
24                 console.log(arg);//没有报错，undefined
25             }
26         }
27         func(4);

 1     //ES6的块级作用域
 2         function f1(){
 3             let n=5;
 4             if(true){
 5                 let n=10;
 6             }
 7             console.log(n);//5
 8         }
 9         f1();
10
11
12         //ES5只有全局作用域和函数作用域，没有块级作用域。
13         function f1(){
14             var n=5;
15             if(true){
16                 var n=10;
17             }
18             console.log(n);//10
19         }
20         f1();
21
22         //块级作用域的出现，实际上使得获得广泛应用的立即执行函数表达式（IIFE）不再必要了。
23         // IIFE 写法
24             (function () {
25               var tmp = ...;
26               ...
27             }());
28
29             // 块级作用域写法
30             {
31               let tmp = ...;
32               ...
33             }
34
35
36             function f() { console.log('I am outside!'); }
37
38             (function () {
39               function f() { console.log('I am inside!'); }
40               if (false) {
41               }
42               f();
43             }());