const

const 意为常量，常量的值不能通过重新赋值来改变，并且不能重新声明。

  1. const number = 42;
  3. number = 99     // error: invalid assignment to const `number'
  4. let number = 66 // error: redeclaration of const `number`

描述

const声明创建一个值的只读引用，但这并不意味着它所持有的值是不可变的，只是变量标识符不能重新分配。例如，在引用内容是对象的情况下，这意味着可以改变对象的内容（比如，其参数）

  1. // 注意: 常量在声明的时候可以使用大小写，但通常情况下全部用大写字母。 
  3. // 定义常量MY_FAV并赋值7
  4. const MY_FAV = 7;
  6. // 报错
  7. MY_FAV = 20;
  9. // 输出 7
  10. console.log("my favorite number is: " + MY_FAV);
  12. // 尝试重新声明会报错 
  13. const MY_FAV = 20;
  15. //  MY_FAV 保留给上面的常量，这个操作会失败
  16. var MY_FAV = 20; 
  18. // 也会报错
  19. let MY_FAV = 20;
  22. // 注意块范围的性质很重要
  23. if (MY_FAV === 7) { 
  24.     // 没问题，并且创建了一个块作用域变量 MY_FAV
  25.     // (works equally well with let to declare a block scoped non const variable)
  26.     let MY_FAV = 20;
  28.     // MY_FAV 现在为 20
  29.     console.log('my favorite number is ' + MY_FAV);
  31.     // 这被提升到全局上下文并引发错误
  32.     var MY_FAV = 20;
  33. }
  37. // MY_FAV 依旧为7
  38. console.log("my favorite number is " + MY_FAV);
  40. // 常量要求一个初始值
  41. const FOO; // SyntaxError: missing = in const declaration
  43. // 常量可以定义成对象
  44. const MY_OBJECT = {"key": "value"};
  46. // 重写对象和上面一样会失败
  47. MY_OBJECT = {"OTHER_KEY": "value"};
  49. // 对象属性并不在保护的范围内，下面这个声明会成功执行
  50. MY_OBJECT.key = "otherValue";
  54. // 也可以用来定义数组
  55. const MY_ARRAY = [];
  56. // It's possible to push items into the array
  57. // 可以向数组填充数据
  58. MY_ARRAY.push('A'); // ["A"]
  59. // 但是，将一个新数组赋给变量会引发错误
  60. MY_ARRAY = ['B']

let

let语句声明一个块级作用域的本地变量，并且可以选择将其初始化为一个值。

  1. let x = 1;
  3. if (x === 1) {
  4.   let x = 2;
  6.   console.log(x);
  7.   // expected output: 2
  8. }
  10. console.log(x);
  11. // expected output: 1

描述

let与var关键字不同的是，var声明的变量只能是全局或者整个函数块的，let在编译的时候才会被初始化。

  1. function varTest() {
  2.   var x = 1;
  3.   {
  4.     var x = 2;  // 同样的变量!
  5.     console.log(x);  // 2
  6.   }
  7.   console.log(x);  // 2
  8. }
  10. function letTest() {
  11.   let x = 1;
  12.   {
  13.     let x = 2;  // 不同的变量
  14.     console.log(x);  // 2
  15.   }
  16.   console.log(x);  // 1
  17. }

在程序和方法的最顶端，let不像 var 一样，let不会在全局对象里新建一个属性。比如：

位于函数或代码顶部的var声明会给全局对象新增属性, 而let不会。例如:

  1. var x = 'global';
  2. let y = 'global';
  3. console.log(this.x); // "global"
  4. console.log(this.y); // undefined

重复声明 (important)

在同一个函数或块作用域中重复声明同一个变量会引起SyntaxError

  1. if(x){
  2.     let foo;
  3.     let foo; // SyntaxError thrown
  4. }

同样的，在switch语句中只有一个块，可能因此也遇到错误。

  1. let x = 1;
  2. switch(x) {
  3.   case 0:
  4.     let foo;
  5.     break;
  7.   case 1:
  8.     let foo; // SyntaxError for redeclaration.
  9.     break;
  10. }

然而，需要特别指出的是，一个嵌套在 case 子句中的块会创建一个新的块作用域的词法环境，就不会产生上诉重复声明的错误。

  1. let x = 1;
  3. switch(x) {
  4.   case 0: {
  5.     let foo;
  6.     break;
  7.   }  
  8.   case 1: {
  9.     let foo;
  10.     break;
  11.   }
  12. }

暂存死区

与通过 var 声明的有初始化值 undefined 的变量不同，通过 let 声明的变量直到它们的定义被执行时才初始化。在变量初始化前访问该变量会导致 ReferenceError。该变量处在一个自块顶部到初始化处理的“暂存死区”中。

  1. function do_something() {
  2.   console.log(bar); // undefined
  3.   console.log(foo); // ReferenceError
  4.   var bar = 1;
  5.   let foo = 2;
  6. }