ES6中Set和Map数据结构的方法有哪些

Set

1、Set是ES6提供的新的数据结构，类似于数组，但是成员的值都是唯一的、不重复的。
2、向Set中添加成员时，不会发生类型转换
3、Set中的对象总是不相等的

Set实例的操作方法

		let set = new Set();
        //add(value):添加某个值，返回Set结构本身
        set.add(1).add(2).add(1).add(3);    //1,2,3
        //delete(value):删除某个值，返回一个布尔值，表示是否删除成功
        set.delete(1);
        //has(value)：该值是否为Set的成员，返回一个布尔值
        set.has(2);
        //clear()：清除所有成员，没有返回值
        set.clear();

Set实例的遍历操作

1、Set结构没有键名，只有键值（或者说键名和键值是同一个值），所以keys()方法和values()方法的行为完全一致。
2、可以直接用for…of 遍历Set

let set = new Set(['a','b','c'])
        //1、keys():返回键名的遍历器
        for(let item of set.keys()){
            console.log(item)
        }
        //a
        //b
        //c
        //2、values()：返回键值的遍历器
        for(let item of set.values()){
            console.log(item)
        }
        //a
        //b
        //c
        //3、entries():返回键值对的遍历器
        for(let item of set.entries()){
            console.log(item)
        }
        //['a','a']
        //['b','b']
        //['c','c']
        //4、forEach()：使用回调函数遍历每个成员
        set.forEach((value,key) => {
            console.log(value,key);
        })
        //a a
        //b b
        //c c
        //5、直接使用for...of循环遍历
        for(let item of set){
        	console.log(item)
        }

数组的map和filter方法

数组的map和filter方法也可以用于Set
用扩展运算符将Set结构转换为数组后使用map和filter方法

map：对数组中的元素进行加工处理，会生成一个新的数组，不会影响原数组。
语法：array.map((currentValue,index,arr => {}))
currentValue:必须，当前元素的值
index：可选，当前元素的索引
arr：可选，当前元素属于的数组对象

filter:根据过滤条件，删除原数组的数据，形成一个新的数组，不会修改原数组。

		let set = new Set([1,2,3,4,3]);
        //map方法
        let setArr = [...set].map(item => {
            console.log(item);
        })
        //filter方法
        let setarr = [...set].filter(item => {
            item%2==0;
        })

去除数组重复的方法

Array.from():将一个类数组对象或者可遍历对象转换为一个真正的数组。

//1
[...new Set(array)]
//2
Array.form(new Set(array))

Map

js中的对象只接受字符串作为键，为了解决这个问题，ES6提供了Map数据结构。Map数据结构类似于对象，也是键值对的集合，但是键的范围不限于字符串，各种类型的值都可以作为键。

正如上图，最终结果不是我们想要的结果。那我们使用Map数据结构来解决这个问题。

Map构造函数接受数组作为参数时，实际上执行的是下面的算法。

var arr = [['a',1],['b',2]]
var map = new Map()
arr.forEach((key,value) => {
   map.set(key,value)
})

只有对同一个对象的引用，Map结构才将其视为同一个键。

var map = new Map();
map.set(['a'],1);
map.get(['a'])  //undefined

set和get方法表面上都是针对同一个键[‘a’],但实际上这是两个值，因为他们的内存地址不一样。Map的键是跟内存地址绑定在一起的，只要内存地址不一样，就是两个键。

实例的属性和操作方法

		let map = new Map()
        // 1、set(key,value),返回整个Map结构
        map.set('a',1)
        map.set(b,2)
        map.set(undefined,3)
        //采用链式写法
        map.set(1,'a').set(2,'b')
        // 2、size
        map.size  //5
        //3、get(key)，读取key对应的键值
        map.get('a')   //1
        //4、has(key),某个键是否存在Map数据结构中，返回一个布尔值
        map.has(b)   //true
        //5、delete(key),删除某个键，返回布尔值
        map.delete(1)//true
        //6、clear()，清除所有成员，无返回值
        map.clear()

与其他数据结构的互相转换

Map转为数组

var map = new Map().set(a,1).set(b,2)
[...map]

数组转为Map

new Map([[a,1],[b,2]])

Map转为对象

function strMapToObj(strMap) {
  let obj = Object.create(null);
  for (let [k,v] of strMap) {
    obj[k] = v;
  }
  return obj;
}

let myMap = new Map().set('yes', true).set('no', false);
strMapToObj(myMap)

对象转为Map

function objToStrMap(obj) {
  let strMap = new Map();
  for (let k of Object.keys(obj)) {
    strMap.set(k, obj[k]);
  }
  return strMap;
}

objToStrMap({yes: true, no: false})

Map转为JSON

function strMapToJson(strMap) {
  return JSON.stringify(strMapToObj(strMap));
}

let myMap = new Map().set('yes', true).set('no', false);
strMapToJson(myMap)

JSON转为Map

function jsonToStrMap(jsonStr) {
  return objToStrMap(JSON.parse(jsonStr));
}

jsonToStrMap('{"yes":true,"no":false}')