ES6新增声明格式

let变量声明及特性

let变量是ES6新增的申明格式，用于补齐ES5标准中var声明变量的不足

1、let 声明的变量不能重复声明
使用ES6语法中的let重复声明一个变量就会报错，这样能防止变量污染

let a = "心猿";
let a = "意马";

使用ES5语法中的var重复声明一个变量，则能正常输出打印。

var a = "心猿";
var a = "意马";
console.log(a);

---

2、let 声明的变量只在块级作用域有效
块级作用域用{}表示

在块级作用域中使用let申明的变量，在块级作用域外，是无法访问的

    {
        let a = 10
    }
    console.log(a)

在块级作用域中使用var申明的变量,在块级作用域外，是可以访问的

    {
        var = 10
    }
    console.log(a)

---

3、let不存在申明变量提升
let声明的变量不会使变量提升，提前打印该变量会报错

	console.log(a)
    let = 10

在JavaScript中用var来声明变量会出现变量提升的情况，即通过var声明的变量，系统都会把声明隐式的升至顶部，提前打印会输出undefined

	console.log(a)
    var = 10

---

4、let申明变量不会影响作用链

    {
        let name = "江流"
        function fn(){
            console.log(name);
        }
        fn()
    }

---

const常量声明及特性

使用const声明的是常量，常量的值不能通过重新赋值来改变，并且不能重新声明

1、const声明的常量一定要赋初始值

 const A = 10;

不赋初始值会报错

 const A;//不赋初始值会报错

2、 const声明的常量一般常量使用大写（潜规则）
使用小写也没有关系。

 const A = 10; 

3、 const声明的常量只在块级作用域有效,在块级作用域外，是无法访问的

     {
         const A = 10;
     }
     console.log(A);

4、 对于数组和对象的元素修改，不算是对常量的修改

    const ARR =  ["江流","心猿","木龙","刀圭"];
    ARR.push("意马");
    console.log(ARR);

---

变量解构赋值

Spread / Rest 操作符 ：Spread / Rest 操作符指的是 ...，具体是 Spread 还是 Rest 需要看上下文语境。

1. 当被用于迭代器中时，它是一个 Spread 操作符：迭代器 (Iterator)是按照一定的顺序对一个或多个容器中的元素行进遍历的一种机制

    function foo(x,y,z) {
      console.log(x,y,z);
    }
    let arr = [1,2,3];
    foo(...arr); // 1 2 3

2. 当被用于函数传参时，是一个 Rest 操作符：当被用于函数传参时，是一个 Rest 操作符：

 function foo(...args) {
   console.log(args);
 }
 foo( 1, 2, 3, 4, 5); // [1, 2, 3, 4, 5]

3. 在ES6中允许按照一定模式从数组和对象中提取值，对变量进行赋值，这称为解构赋值

数组结构

1. 一一对应关系的赋值
   等号右边的值会按照顺序依次赋值给左边的变量。

        const ARR = ["江流", "心猿", "木龙", "刀圭"];
        let [a, b, c, d] = ARR;
        console.log(a, b, c, d);

2. 非一一对应关系的赋值

    let [a,b] = [10,20,30]
    console.log(a,b); //输出10,20

    let [a,b,c] = [10,20]
    console.log(a); //10
    console.log(b); //20
    console.log(c); //undefined

3. 也可以通过...把特定的元素放在变量里

      let [a,...arr] = [10,20,30]
      console.log(a); //10
      console.log(arr); //20,30

4. 在ES6中可以通过解构赋值来互换变量

      let a = 10;
      let b = 20;
      [a,b] = [b,a];
      console.log(a,b)//20,10

对象的解构

1. 对象解构的写法与数组解构类似

    let obj = {
        name: '张三',
        age: 20,
        height: '178com'
    }

    let { name,age,height } = obj; //变量的名称必须和对象的属性名相同
      console.log(name,age,height);

2. 也可以解构多层对象

      let person = {
          name: '张三',
          age: 20,
          family: {
              father: '张武',
              mother: '李燕'
          }
      }
      let { name,age,family: {father,mother }} = person
      console.log(name,father)

3. 在解构对象时也可以自定义变量名称：

      let obj = {
          name: '张三',
          age: 20
      }
      let { name:myname,age:myage } = obj;
      console.log(myname,myage);

4. 解构的默认值和参数的解构：

(1)不管是数组的解构赋值,还是对象的解构赋值都可以添加默认参数。如下：

  let obj = {
      name: '李四',
      age: 20
  }

  let { name,age,height="178cm" } = obj;
  console.log(height); //178cm

(2)在函数参数中使用解构,参数解构也可以给默认参数

      function fun({name,age,height="178com"} = {}){
          console.log(name,age); //张三,20
      }
      let obj = {
          name: '张三',
          age: 20
      }
      fun(obj)//张三 20

---

模板字符串

ES6引入新的声明字符串的方式``

1. 申明字符串

let str =  `我是一个字符串`;
console.log(str);

2. 内容中可以直接出现换行符

 let str = `
    <ul>
        <li>第1天</li>
        <li>第2天</li>
        <li>第3天</li>
        <li>第4天</li>
        <li>第5天</li>
    </ul>`;
console.log(str);

3. 字符串的拼接,模板字符串通过反引号来表示``,如果要嵌入变量通过${ 变量名 }来实现：

  let str = "马少爷";
  console.log(`${str},你爸真有钱！！！`);