ECMAScript 变量是松散类型的，意思是变量可以用于保存任何类型的数据。每个变量只不过是一
个用于保存任意值的命名占位符。有3 个关键字可以声明变量：var、const 和let。其中，var 在
ECMAScript 的所有版本中都可以使用，而const 和let 只能在ECMAScript 6 及更晚的版本中使用。

var

定义变量 

  1. var message;
  3. var message = 123;

var 的两个特性

  1. var 声明作用域
  2. var 具有变量提升 ```javascript // 1.声明作用域 function test() { var message = ‘hi’; // 局部变量 } test(); console.log(message); // 出错

// 2. var 的变量提升 function foo () { console.log(age); // 变量提升 var age = 22; } foo() // undefined

// 以上代码等价为 function foo () { var age; console.log(age); // 变量提升 age = 22; } foo() // undefined

  2. <a name="vGXj1"></a>
  3. # let 
  5. 1. **let具有块级作用域**
  6. 2. **不能重复声明**
  7. 3. **不能和var混合使用**
  8. 4. **没有变量提升**
  10. ```javascript
  11. //1. 块级作用域
  13. {
  14.     let a = 'message';
  15. }
  16. console.log(a);
  20. // 2. 不能重复声明
  21. let a = 'a';
  22. let a = 'a';  // SyntaxError
  26. // 3. 不能和var 混用
  27. let name = 'yellowsea';
  28. var name = 'yellowsea'; // SyntaxError
  32. // 4. 没有变量提升
  33. console.log(name); // 没有声明
  34. let name = 'yellowsea';
  38. // 5. let 没有全局声明
  39. var name = 'yellowsea';
  40. console.log(window.name); // 'yellowsea'
  42. let age = 26;
  43. console.log(window.age); // undefined

for循环使用let为迭代变量

  1. // 使用var为迭代变量 
  2. for (var i = 0; i < 5; i++) {}  // 迭代遍历会渗透到循环体外部
  3. console.log(i);  // 5
  6. // 改用let 为迭代变量
  7. for (let i = 0; i < 5; i++) {} 
  8. console.log(i); // i 没有定义

var 和 let 常见的情况

  1. for (var i = 0; i < 5; i++) {
  2.     setTimeout(() => {
  3.         console.log(i)
  4.     }, 0)
  5. }
  7. // 立即输出 5 5 5 5 5

之所以会这样，是因为在退出循环时，迭代变量保存的是导致循环退出的值：5。在之后执行超时 逻辑时，所有的i 都是同一个变量，因而输出的都是同一个最终值。

  1. for (let i = 0; i < 5; i++) {
  2.     setTimeout(() => {
  3.         console.log(i)
  4.     }, 0)
  5. }
  6. // 输出 0, 1, 2, 3, 4,

而在使用let 声明迭代变量时，JavaScript 引擎在后台会为每个迭代循环声明一个新的迭代变量。 每个setTimeout 引用的都是不同的变量实例，所以console.log 输出的是我们期望的值，也就是循 环执行过程中每个迭代变量的值。

const

  1. const 定义变量不允许修改
  2. 不能重读声明
  3. 具有块级作用域
  4. const 定义的对象可以修改属性值
  5. const声明变量必须赋值


  1. // 1. const 定义的变量不允许修改
  3. const NAME = "Yellowsea";
  4. NAME = "Hidie"; // TypeError
  8. // 2. const 定义的变量不允许重复声明
  9. const NAME = 'TEST';
  10. const NAME = 'test'; // SyntaxError
  15. // 3. const 具有块级作用域
  16. {
  17.     const NAME = 'TEST';
  18. }
  19. const NAME = 'test';
  23. //4. const 定义的对象可以修改属性值
  24. const YELLOWSEA = {
  25.     name: 'Yellowsea',
  26.     age: 123
  27. }
  28. YELLOWSEA.age = 456;
  29. console.log(YELLOWSEA) // { name: 'Yellowsea', age: 456 }
  32. // 5. const声明变量必须赋值
  33. const age; // SyntaxError

声明变量的风格

const > let > var

var let const 的区别

  1. 变量提升
  2. 块级作用域
  3. 重复声明 -> var 可以重复声明 ， let const 不能重复声明变量
  4. 暂时性死区 -> 暂时性死区： 使用const 和 let 定义变量之前， 该变量都是不可用的。 在语法上成为暂时性死区。
  5. let 和 var 可以声明是不用赋值， const 声明时候必须要赋值