121_ES6 笔记2_新增关键字：let，const，symbol

一，新增关键字：let和const

1. 有效范围
   1. let 声明的变量只在代码块内有效。
   2. var 声明的变量在在全局范围内有效,
   3. 函数内用let，var，const修饰的，在函数外均不能使用
2. let 只能声明一次， var 可以声明多次

   1. //以下会报错：Identifier 'a' has already been declared
      let a = 1;
      let a = 2;
      
      //以下正常
      var b = 3;
      var b = 4;

3. 循环控制变量，非常适合let

   1. // 使用var控制变量
      for (var i = 0; i < 10; i++) {
        setTimeout(function(){
          console.log(i);
        })
      }
          // 输出十个 10
      
      // 使用let控制变量
      for (let j = 0; j < 10; j++) {
        setTimeout(function(){
          console.log(j);
        })
      }
          // 输出 12345

4. let 不存在变量提升，var 会变量提升

   1. //let关键字
      console.log(a);  
      let a = "apple";
      //会报错：ReferenceError: a is not defined
       
      //var关键字
      console.log(b);  
      var b = "banana";
      //不会报错，已经存在了，但是还没有赋值undefined
5. const一但声明必须初始化，否则会报错

   1. const PI = "3.1415926";
      PI  // 3.1415926
      
      const MY_AGE;  // SyntaxError: Missing initializer in const declaration    

6. const声明初始化后，如果改变值就会报错
   1. 本质是保证变量指向的内存地址所保存的数据不允许改动
   2. 对于简单类型（数值 number、字符串 string 、布尔值 boolean）,值就保存在变量指向的那个内存地址，因此 const 声明的简单类型变量等同于常量
   3. 复杂类型（对象 object，数组 array，函数 function），变量指向的内存地址其实是保存了一个指向实际数据的指针，所以 const 只能保证指针是固定的，至于指针指向的数据结构变不变就无法控制了，所以使用 const 声明复杂类型对象时要慎重
7. let和const，在代码块内的暂时性死区

   1. //1，打印正常
      var PI = "a";
      if(true){
        console.log(PI);  
      }
      
      //2，报错 ReferenceError: PI is not defined
      var PI = "a";
      if(true){
        console.log(PI);  
        const PI = "3.1415926";
      }
      
      //3，报错 ReferenceError: PI is not defined
      var PI = "a";
      if(true){
        console.log(PI);  
        let PI = "3.1415926";
      }

二，symbol关键字

1. ES6 引入了一种新的原始数据类型 Symbol ，表示独一无二的值，最大的用法是用来定义对象的唯一属性名。
2. ES6 数据类型除了 Number 、 String 、 Boolean 、 Objec t、 null 和 undefined ，还新增了 Symbol
3. Symbol值通过Symbol函数生成，Symbol 函数钱不能用 new 命令，因为 Symbol 是原始数据类型，不是对象

   1. let sy = Symbol("KK");
      console.log(sy);   // Symbol(KK)
      typeof(sy);        // "symbol"
       
      // 相同参数 Symbol() 返回的值不相等
      let sy1 = Symbol("kk"); 
      sy === sy1;       // false

4. 应用1：设置属性

   1. let sy = Symbol("key1");
       
      // 写法1：对象 + 【】
      let syObject = {};
      syObject[sy] = "kk";
      console.log(syObject);    // {Symbol(key1): "kk"}
       
      // 写法2：【】 + ：
      let syObject = {
        [sy]: "kk"
      };
      console.log(syObject);    // {Symbol(key1): "kk"}
       
      // 写法3：defineProperties
      Object.defineProperties(syObject,sy,{value:"kk"});
      console.log(syObject);    // {Symbol(key1): "kk

5. 应用2：获取symbol类型的属性
   1. 不能使用点语法
   2. 不会出现在 for...in 、 for...of 的循环中
   3. 不会被 Object.keys() 、 Object.getOwnPropertyNames() 返回
   4. 可以通过 Object.getOwnPropertySymbols() 和 Reflect.ownKeys() 取到

   5. let syObject = {};
      let sy = Symbol("key1");
      syObject[sy] = "kk";
      
      // 1，点语法无输出
      console.log(syObject.sy); 
      
      // 2，for循环无输出
      for (let i in syObject) {
      	console.log(i);
      }    
      // 3，keys方法无输出
      console.log(Object.keys(syObject));     
      
      // 4，getOwnPropertyNames方法无输出
      console.log(Object.getOwnPropertyNames(syObject));                  
      
      // 5，getOwnPropertySymbols有输出
      console.log(Object.getOwnPropertySymbols(syObject));    // [Symbol(key1)]
      
      // 6，Reflect.ownKeys有输出
      console.log(Reflect.ownKeys(syObject));                 // [Symbol(key1)]
      
      运行结果：
      undefined
      []
      []
      [ Symbol(key1) ]
      [ Symbol(key1) ]

6. 定义常量
   1. 保证每一组常量都不一样
   2. 不会出现相同值得常量，即可以保证 switch 按照代码预想的方式执行。

   3. const COLOR_RED = Symbol("red");
      const COLOR_YELLOW = Symbol("yellow");
      const COLOR_BLUE = Symbol("blue");
       
      function getConstantName(color) {
          switch (color) {
              case COLOR_RED :
                  return "COLOR_RED";
              case COLOR_YELLOW :
                  return "COLOR_YELLOW ";
              case COLOR_BLUE:
                  return "COLOR_BLUE";
              default:
                  throw new Exception('Can't find this color');
          }
      }

7. symbol的三个函数区别：Symbol(),Symbol.for(),Symbol.keyFor()
   1. Symbol()：一般定义Symbol类型的函数,未被全局登记；
   2. Symbol.for()和Symbol.keyFor()类似单例模式；
   3. Symbol.for()：在全局搜索被登记的 Symbol 中是否有该字符串参数作为名称的 Symbol 值，如果有即返回该 Symbol 值，若没有则新建并返回一个以该字符串参数为名称的 Symbol 值，并登记在全局环境中供搜索
   4. Symbol.keyFor()：返回一个已登记的 Symbol 类型值的 key ，用来检测该字符串参数作为名称的 Symbol 值是否已被登记

   5. //一般symbol函数
      let yellow1 = Symbol("Yellow");
      //全局symbol函数
      let yellow2 = Symbol.for("Yellow");
      //全局symbol函数
      let yellow3 = Symbol.for("Yellow");
      
      console.log(yellow1 === yellow2);
      console.log(yellow2 === yellow3);
      
      //Symbol.keyFor函数
      console.log(Symbol.keyFor(yellow1));
      console.log(Symbol.keyFor(yellow2));
      console.log(Symbol.keyFor(yellow3));
      
      结果：
      false
      true
      undefined
      Yellow
      Yellow