test

简介

ES6（2015），ECMAScript6.0，是JavaScript的 下一个版本标准。JavaScript是ECMAScript的实现，ECMAScript是JavaScript的标准。

let 和 const

• let声明的变量只在let命令所在的代码块中有效
• const声明一个只读常亮，一旦声明不能再被更改

let代码块中有效，var全局范围内有效且存在变量提高(即定义在后面的变量，前面能够访问到).

{
    var a = 3;/*全局都共享*/
    let b = 2;/*被限定在代码块中*/
}
console.log(a);/*3*/
//console.log(b);/*Uncaught ReferenceError: a is not defined*/

const声明一个只读变量，声明以后不容许修改，必须初始化。

{
    const PI = 3.14;
    /*编译器直接报错*/
    PI = 3.15;/*attempt to assign to const or readonly variable*/
    console.log(PI);
}

注：这里的常量保证的只是地址不变，若是是基本类型，则保证数据不变；但若是是对象，只是保证对象的引用地址不变，对象里面的属性值依然能够改变

{
    const person={
        name:"wade",
        age:20
    }
    person.name="peter";
    console.log(person);/*{name: "peter", age: 20}*/
    console.log(person.name);/*peter*/
}

解构函数

针对数组或者对象进行模式匹配，而后对其中的变量进行赋值。

解构的源=解构的目标 ，注意：左右解构要同样

数组（Array）

1. 左右映射，对应

   //基本
   {
       let [a, b, c] = [1, 2, 3];
       console.log(a, b, c)//1 2 3
   }
   //嵌套
   {
       let [a, [b, c]] = [3, [5, 7]];
       console.log(a, b, c)//3 5 7
   }
   
   //忽略
   {
       let [a, , b, c,] = [1, 3, 5, 6, 7];
       console.log(a, b, c)//1 5 6
   }

   2. 默认值，没有对应的能够给默认值

      {
          let [a = 1, b] = [, 10];
          console.log(a,b)//1 10
      }

   3. 剩余运算符

      {
          let [a,...b]=[1,2,3,5]
          console.log(a)//1
          console.log(b)//[2,3,5]
      }

   对象（Object）

   对象解构与数组解构相似，注意{}与[]区别，左右对应便可，能匹配上就是右边的值，不能匹配上就是undefined。

   {
       let {name, age} = {name: 'wade', age: 18};
       console.log(name, age)//wade 18
   }
   
   {
       let {name,...other}={name:'wade',age:12,sex:'male',height:'150'}
       console.log(name)//wade
       console.log(other)//{age: 12, sex: "male", height: "150"}
   }

Symbol

定义一种新的类型，表示独一无二的值，最大的用法用来定义惟一的属性名。

ES6 数据类型除了 Number 、 String 、 Boolean 、 Object、 null 和 undefined ，还新增了 Symbol 。

用法

• Symbol 函数栈不能用 new 命令，由于 Symbol 是原始数据类型，不是对象。能够接受一个字符串做为参数，为新建立的 Symbol 提供描述，用来显示在控制台或者做为字符串的时候使用，便于区分。

{
    let str1 = Symbol("abc");
    console.log(str1)//Symbol(abc)
    console.log(typeof(str1));symbol

    let str2 =Symbol("abc");
    console.log(str1 == str2)//false
}

做为属性名，保证属性不重名

let name = Symbol("name");
let age = Symbol("age");
{
    let obj = {
        [name]: "wade",
        [age]: 18
    }
    console.log(obj[name],obj[age])//wade 18
    console.log(obj.name)//undefined
}

注：只能经过obj[symbolName]去取值，不能经过点。

Map 与 Set

Map

Map 对象保存键值对。任何值(对象或者原始值) 均可以做为一个键或一个值。

map.set(key:any,value:any)

Maps 和 Objects 的区别

• 一个 Object 的键只能是字符串或者 Symbols，但一个 Map 的键能够是任意值。
• Map 中的键值是有序的（FIFO 原则），而添加到对象中的键则不是。
• Map 的键值对个数能够从 size 属性获取，而 Object 的键值对个数只能手动计算。
• Object 都有本身的原型，原型链上的键名有可能和你本身在对象上的设置的键名产生冲突。

用法：

{
    let map = new Map();
    let str = "key1";
    map.set(str, "123");
    let obj = {};
    map.set(obj, {name: 10});
    let bool = true;
    map.set(bool, 123);
    let boo=true;
    map.set(boo,234);//当map中存在此key时，会将原来的值替换

    console.log(map.get(str))//123
    console.log(map.get(obj))//{name:10}
    console.log(map.get(bool))//234
    console.log(map.get(boo))//234
}

for ... of 遍历

//for...of
for (let [key, val] of map) {
    console.log(key, val)
}

for (let [key,val] of map.entries()){
    console.log(key,val);
}

for (let key of map.keys()){
    console.log(key)
}

for (let val of map.values()){
    console.log(val)
}

forEach

map.forEach(function (val, key) {
    console.log(val,key)
})

Map <-----> Array

{
    let map=new Map();
    map.set("k1","wade");
    map.set("k2","peter");

    //map to array
    let arr = Array.from(map);
     /*
     (2) [Array(2), Array(2)]
          0: (2) ["k1", "wade"]
          1: (2) ["k2", "peter"]*/
    console.log(arr)
    //array to map
    let mapFormArr = new Map(arr);
    
    /*
    Map(2) {"k1" => "wade", "k2" => "peter"}
        [[Entries]]
        0: {"k1" => "wade"}
        1: {"k2" => "peter"}
    * */
    console.log(mapFormArr)
}

Set

Set 对象容许你存储任何类型的惟一值，不管是原始值或者是对象引用。

Set 中的特殊值

Set 对象存储的值老是惟一的，因此须要判断两个值是否恒等。有几个特殊值须要特殊对待：

• +0 与 -0 在存储判断惟一性的时候是恒等的，因此不重复；
• undefined 与 undefined 是恒等的，因此不重复；
• NaN 与 NaN 是不恒等的，可是在 Set 中只能存一个，不重复。

{
    let set = new Set();
    set.add(1);
    set.add("a");
    set.add("a");
    set.add({name: "wade"})


    console.log(set)//Set(3) {1, "a", {…}}
}

集合操做详情