js中的Map和Set对象

一、Map对象

1. Map 对象保存键值对，并且能够记住键的原始插入顺序。任何值（对象或者原始值）都可以作为一个键或一个值。

   1. map.set(key,value) 设置值
   2. map.get(key) 获取值
   3. map.size()获取集合的大小
   4. map.delete(key)删除map的某一项
   5. map.has(key) 查看map集合是含有该键元素
   6. map.clear()清除所有的键值对

   const map = new Map()
   // 1. map.set(key,value)是设置值
   map.set('a', 1)
   map.set('b', 2)
   map.set('c', 3)
   map.set(NaN, 4)
   console.log(map);
   // 2. 根据键获取值需要使用map.get(key)方法
   console.log(map.get('a'));
   // 3. 获取map集合的大小 map.size
   console.log(map.size);
   // 4. 根据map.has(key)判断是否含有这个元素
   console.log(map.has('a'));
   // 5. map.delete(key)来删除map集合的某一项
   map.delete('a')
   console.log(map);
   // 6. map.clear清除所有键值对
   map.clear()
   console.log(map);
   // Map构造函数
   // 实例属性
   /*
     上面的6个方法对应6个原型方法
     1. Map.prototype.set()
     2. Map.prototype.get()
     //实例属性
     3. Map.prototype.size
     4. Map.prototype.clear()
     5. Map.prototype.delete()
     6. Map.prototype.has()
     NaN也可以做map的键
   */
   

   7. NaN也可以作为map的键 因为NaN！=NaN

       var map=new Map()
       map.set(NaN,'111')
       console.log(map);
       console.log( map.get(NaN));
   	//Map(1) {NaN => '111'}
   	//11
   

   8. 可以使用forEach和for of迭代map

      1. for of 迭代

          var map=new Map()
          //第一种创建map集合形式 空集合 然后添加
          map.set('a',1)
          map.set('b',2)
          map.set('c',3)
          map.set('d',4)
          map.set('e',5)
          map.set('f',6)
          console.log(map);
          // 获取键和值
          for (const [key,value] of map) {
            console.log(`${key},${value}`);
          }
          // 获取键
          for (const keys of map.keys()) {
            console.log(keys);
          }
          // 获取值
          for (const value of map.values()) {
            console.log(value);
          }
          // 获取键和值
          for (const [key,value] of map.entries()) {
            console.log(`${key},${value}`);
          }
      

      2. forEach迭代

      	//第二种创建集合方式 new的时候 直接添加
      	var map=new Map([
            ['a',1],
            ['b',2],
            ['c',3],
            ['d',4],
          ])
          // console.log(map);
          map.forEach((value,key) => {
            console.log(`${value},${key}`);
          });
      

      3. map和和数组之间的关系
         1. map可以把一个二维键值对数组转为map集合

          var arr=[['a',1],['b',2]]
          var map=new Map(arr)
          console.log(map);
          console.log(map.get('a'));
      	//1
      

      4. Array.form可以 把map集合转为二维数组键值对

          var arr=[['a',1],['b',2]]
          var map=new Map(arr)
          console.log(map);
          console.log(map.get('a'));
          let newArr=Array.from(map)
          console.log(newArr);
      -------------------------------------------------------------
          //简单的当时做上面的事情
          console.log([...map]);
      	//把map的键转为数组	
          console.log([...map.keys()]);
      	//把map的值转为数组
          console.log([...map.values()]);
      

   9. 复制或者合并map

          var map1=new Map([
            ['a',1],
            ['b',2]
          ])
          var map2=new Map(map1)
          console.log(map2.get('a'));
          console.log(map1==map2);
          //不为同一个对象的引用
          var map3=new Map([
            ['aa',11],
            ['bb',22],
            ['cc',33]
          ])
          var map4=new Map([
            ['dd',44],
            ['aa',000]
          ])
          var merge=new Map([...map3,...map4])
          //合并map 当二者key一致时，后面会覆盖前面
          console.log(merge);
      

   10. map与数组合并为map

           var map5=new Map([
             ['aaa',111],
             ['bbb',222]
           ])
           var map6=new Map([
             ['ccc','333']
           ])
           var merge2=new Map([...map5,...map6,['ddd',444]])
           console.log(merge2);
       

二、Set对象

Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用。

set对象是值的集合，你可以按照插入顺序迭代它的元素。set元素只会出现一次，即set元素是唯一的

1. NaN和undefined都可以存储在Set中，NaN之间被视为相同的值
2. set.add(value) 添加元素
3. set.delete(value) 删除元素
4. set.size() 获取set集合大小
5. set.has(value) 判断是否有value 返回布尔值
6. set.clear() 删除value的而所有元素
7. set.entries() 返回迭代器对象 键和值相等
8. set.keys() 返回迭代器对象所有的key
9. set.values() 返回迭代器对象所有的value 且和8不相等
10. set.forEach(callback(key,value,self)=>{})

    let mySet = new Set()
    mySet.add(1)
    mySet.add(2)
    mySet.add('something')
    mySet.add({ a: 1, b: 2 })
    console.log(mySet.has(1));
    console.log(mySet.has('something'));
    console.log(mySet.size);
    mySet.delete(1)
    console.log(mySet);
    console.log(mySet.entries());
    // value=>value
    console.log(mySet.keys());
    console.log(mySet.values());
    console.log(mySet.keys()==mySet.values());
	//set迭代
    mySet.forEach((keys,values,self)=>{
      console.log(`${values} ${keys} ${self}`);
    })
	//数组去重
    let arr = [1, 5, 2, 1, 5, 1, 52, 1]
    console.log([...new Set(arr)]);

11. 迭代set

    1. for of

        var set=new Set([1,2,3,4,5])
        for (const item of set) {
          console.log(item);
        }
        for (const key of set.keys()) {
          console.log(key);
        }
        for (const value of set.values()) {
          console.log(value);
        }
        for (const [key,value] of set.entries()) {
          console.log(`${key},${value}`);
        }
    

    2. forEach

        var set=new Set([1,2,3])
        set.forEach(value=>{
          console.log(value);
        })
    

12. set和数组之间转换

    1. 使用Array.form(set) 转为数组 也可以使用[…set]转为数组
    2. 使用new Set(arr) 转为set

        var set=new Set([1,2,3])
        console.log(set);
        let arr=Array.from(set)
        console.log(arr);
    

13. 使用set求差集合交集

        var set1=new Set([1,3,5,8])
        var set2=new Set([2,3,7,9])
        let sum=new Set([...set1].filter(v=>set2.has(v)))
        console.log(sum);
        let diff=new Set([...set1].filter(v=>!set2.has(v)))
        console.log(diff);
    

14. set实现基本集合操作

        // 1. 判断是不是父集的子集
        function isSuperSet(set,subset){
          for (const item of subset) {
            if(!set.has(item))
            {
              return false
            }
          }
          return true
        }
        var set1=new Set([1,2,3,4,5])
        var set2=new Set([1,2,3,0])
        console.log(isSuperSet(set1,set2));
        // 2. 求并集
        function union(setA,setB){
          let union1=new Set(setA)
          for (const item of setB) {
            union1.add(item)
          }
          return union1
        }
        var set3=new Set([1,2])
        var set4=new Set([1,2,4])
        console.log(union(set3,set4));
        // 3. 求交集
        function intersection(setA,setB){
          var newSet=new Set()
          for (const item of setA) {
            if(setB.has(item))
            {
              newSet.add(item)
            }
          }
          return newSet
        }
        var set5=new Set([1,2,5])
        var set6=new Set([1,3,4])
        console.log(intersection(set5,set6));
        // 4. 求差集
        function difference(setA,setB){
          var set=new Set(setA)
          for (const item of setB) {
              set.delete(item)
          }
          return set
        }
        var set7=new Set([1,2,5])
        var set8=new Set([1,3,4])
        console.log(difference(set7,set8));
        // 5.求对等差集 就是二者不同的地方的合集
        function symmetricDifference(setA,setB)
        {
          var newSet=new Set(setA)
          for (const item of setB) {
            if(newSet.has(item))
            {
              newSet.delete(item)
            }
            else{
              newSet.add(item)
            }
          }
          return newSet
        }
        var set9=new Set([1,2,5])
        var set10=new Set([1,3,4])
        console.log(symmetricDifference(set9,set10));
    

15. 与String相关

        var str='helloWorld'
        var set=new Set(str)
        console.log(set);
    	//返回['h','e','l','l','o',W','o','r','l','d']的set集合