ES6新增

目录

1、Symbol  基本数据类型 

2、Map  引用数据类型

3、Set 基本数据类型

1、Symbol  基本数据类型 

        let sm = Symbol()
        console.log(sm);//Symbol()
        console.log(typeof sm);//symbol

        不能用new创建Symbol对象

        let sm = new Symbol()  //报错

         Uncaught TypeError TypeError: Symbol is not a constructor

        Symbol的值不能与其他数据类型的值进行运算

        1）Symbol()每次都会创建一个新的symbol返回

             可选择字符串对symbol进行描述

        let sm1 = Symbol('sm')
        let sm2 = Symbol('sm')
        console.log(sm1==sm2)//false

  

        2）Symbol解决对象属性名冲突

                 当symbol值作为对象的属性名时，不能通过点运算符获取该属性对应的属性值

        第一种

        let name = Symbol()
        let person = {
            [name]:'张三'
        }
        console.log(person[name]);//张三
        console.log(person.name);//undefined

        第二种

         person[name]='张三'

         第三种

        Object.defineProperty(person,name,{value:'张三'})

               当使用点运算符添加对象属性时，会将属性名理解为字符串类型而不是symbol类型

        let name = Symbol()
        let person = {}
        person.name = '张三'
        console.log(person[name]);//undefined
        console.log(person['name']);//张三
        console.log(person.name);//张三

        3）当对象的属性名为symbol类型时，通过Object.getOwnPropertySymbols()获取属性；  for…in、for…of和Object.keys()获取不到该属性

        for(key in person){
            console.log(key);//sex,age
        }
        console.log(Object.keys(person));//['sex', 'age']
        console.log(Object.getOwnPropertySymbols(person));//[Symbol()]

        只有可迭代对象才能使用for…of 

                内置可迭代对象：数组、字符串、Map、Set、arguments、Typed Arrays、Generators

        4）Reflect.ownKeys()获取所有类型的属性 

        console.log(Reflect.ownKeys(person));//['sex', 'age', Symbol()]

        5）Symbol.for(参数名)：根据参数名去全局环境中搜索是否有以该参数为描述符的symbol，有的话返回该symbol，没有的话创建新的symbol返回

        let dafu = Symbol('disney')
        let lina = Symbol.for('disney')
        let bell = Symbol.for('disney')
        console.log(lina === bell);//true
        console.log(lina === dafu);//false

        Symbol()创建的symbol值不会登记到全局环境中，用Symbol.for()搜索不到

        Symnol.for()创建的symbol值才会被登记到全局环境中

        6）Symbol.keyFor()：返回一个被登记在全局环境中的symbol值的key，没有则返回undefined 

        let dafu = Symbol('dafu')
        let bell = Symbol.for('disney')
        console.log(Symbol.keyFor(bell));//disney
        console.log(Symbol.keyFor(dafu));//undefined

2、Map  引用数据类型

        以键值对的形式存储数据

        1）基本语法：new Map()

        let mp = new Map()
        console.log(mp);//Map(0) {size: 0}

        第一种：声明的同时赋值   参数必须是二维数组形式

        let mp = new Map([['key1','value1'],['key2','value2']])
        console.log(mp);//Map(2) {size: 2, key1 => value1, key2 => value2}

        第二种：先声明，再赋值

        let mp = new Map() //声明
        mp.set('key1','value1') //赋值
        console.log(mp);//Map(1) {size: 1, key1 => value1}

        2）Map中的方法

                Map.get() 通过键名获取Map中的键值

        let mp = new Map() //声明
        mp.set('key1','value1') //赋值
        console.log(mp.get('key1'));//value1

                Map.size() 返回Map中的键值对个数

        let mp = new Map([['key1','value1'],['name','bell']]) 
        console.log(mp.size);//2

                 Map.delete()  删除键名对应的键值对

        let mp = new Map([['key1','value1']]) 
        mp.delete('key1')
        console.log(mp);//Map(0) {size: 0}

                Map.clear() 清空所有的键名和数据

        let mp = new Map([['key1','value1'],['name','bell']]) 
        mp.clear()
        console.log(mp);//Map(0) {size: 0}

                Map.has() 判断Map中是否包含该键名

        let mp = new Map([['key1','value1'],['name','bell']]) 
        console.log(mp.has('name'));//true

                Map.forEach()  遍历Map中的键值对

         let mp = new Map([['key1','value1'],['name','bell']]) 
        mp.forEach((key,value,map)=>{
            console.log(key+'=>'+value+'~'+map);//value1=>key1~[object Map]
        })
        let arr=[1,2,3]
        arr.forEach((item,index,arr)=>{
            console.log(item+'>'+index+'>'+arr);//1>0>1,2,3
        }))

                ...Map / Array.from(Map)  将Map转换为数组

                        ...Map：转换为n个数组    [...Map]  返回二维数组

                        Array.from（）转换为长度为n的二维数组

        let mp = new Map([['key1','value1'],['name','bell']]) 
        console.log(...mp);//(2) ['key1', 'value1'] (2) ['name', 'bell']
        let arr = Array.from(mp)
        console.log(arr);//[Array(2), Array(2)]

                Map.keys()：返回Map中所有的键名

                Map.values()：返回Map中所有的值

                Map.entries()：返回Map中所有的键值对

        let mp = new Map([['key1','value1'],['name','bell']]) 
        console.log(mp.keys());//MapIterator {key1, name}
        console.log(mp.values());//MapIterator {value1, bell}
        console.log(mp.entries());//MapIterator {key1 => value1, name => bell}

                Map可迭代    可使用for…of   以数组形式输出键值对

        let mp = new Map([['key1','value1'],['name','bell']]) 
        for(key of mp){
            console.log(key);// ['key1', 'value1']  数组
        }

                二维数组去重-----利用key不可重复  

            let res={}
            // 二维数组去重
            mid.forEach(item=>{
                res[item] = item
            })
            let arr = Object.values(res)

3、Set 基本数据类型

        可以存储任意类型的数据（可迭代）    不允许包含重复的元素

        1）创建和初始化

        const st = new Set('str')
        const st0 = new Set([1,2,3])
        console.log(st0);//Set(3) {size: 3, 1, 2, 3}
        console.log(st);//Set(3) {size: 3, s, t, r}

        2）Set中的方法

                Set.add() 添加set中不存在的元素 并返回添加后的set

        const st0 = new Set([1,2,3])
        console.log(st0.add(3));//Set(3) {size: 3, 1, 2, 3}
        console.log(st0.add('s'));//Set(4) {size: 4, 1, 2, 3, s}

                Set.delete() 删除Set中的元素 并返回删除结果 true/false

        const st0 = new Set([1,2,3])
        console.log(st0.delete(3));//true
        console.log(st0);//Set(2) {size: 2, 1, 2}

                Set.has() 判断Set中是否存在元素

        const st0 = new Set([1,2,3])
        console.log(st0.has(3));//true

                 Set.clear()  清空对象

        const st = new Set('str')
        console.log(st.clear());//undefined
        console.log(st);//Set(0) {size: 0}

                  [...Set] / Array.from()  将Set展开为数组

        const st = new Set('str')
        console.log([...st]);//(3) ['s', 't', 'r']
        console.log(Array.from(st));//(3) ['s', 't', 'r']
        let arr = [...st]
        console.log(arr);//(3) ['s', 't', 'r']
        let [...arr0] = [...st]
        console.log(arr0);//(3) ['s', 't', 'r']

                数组转换为Set对象

        const st = new Set('str')
        let arr = [2,3,4]
        const set = new Set(arr)
        console.log(set);//Set(3) {size: 3, 2, 3, 4}

                Set.values() 返回对象中的所有值

                Set.entries()  以键值对形式返回对象中的所有值

        const st = new Set('str')
        console.log(st.values());//SetIterator {s, t, r}
        console.log(st.entries());//SetIterator {s => s, t => t, r => r}

                交集、差集、并集

                        数组的filter方法  ...运算符

        const bell = new Set(['disney','linabell'])
        const dafu = new Set(['disney','dafu'])
        /* 交集 */
        const disney = new Set(
            [...bell].filter(item=>dafu.has(item))
        )
        console.log(disney);//Set(1) {size: 1, disney}
        /* 并集 */
        const friend = new Set([...dafu,...bell])
        console.log(friend);//Set(3) {size: 3, disney, dafu, linabell}
        /* 差集 */
        const personal = new Set(
            [...dafu].filter(item=>!bell.has(item))
        )
        console.log(personal);//Set(1) {size: 1, dafu}