「这是我参与2022首次更文挑战的第21天，活动详情查看：2022首次更文挑战」。

Map和Set的应用场景

Map 类似于对象，但是键名不限于字符串，可以说 Object 结构提供 键-值 对应， Map 结构提供 值-值 对应因此其实采用 map 结构会优于传统对象

Map的特点

• Map 默认情况下不包含任何键，所有键都是自己添加进去的。不同于 Object 原型链上有一些默认的键。

• Map 的键可以是任意类型数据。

• Map 的键值对个数可以轻易通过size属性获取，Object 需要手动计算。

• Map 在频繁增删键值对的场景下性能要比 Object 好。

什么时候用 Map

• 要添加的键值名和 Object 上的默认键值名冲突，又不想改名时
• 需要 String 和 Symbol 以外的数据类型做键值时
• 键值对很多，有需要计算数量时
• 需要频繁增删键值对时

Map 类型转化

Map 转为数组

通过扩展运算符实现

let m = new Map()
let arr = [...m]

数组转为 Map

let m = new Map(arr)

Map 转为对象

通过遍历利用 set 将键值对加入对象中

let obj = {}
let m = new Map()
for (let [k, v] of m) {
  obj[k] = v
}

对象转为 Map

for( let k of Object.keys(obj)){
  map.set(k,obj[k])
}

Set的应用场景

数组去重

 let arr = [1,2,3,4,5,4,3,2,1], arr2 = [4,5,6,5,6];
    // 1.数组去重
    let res = [...new Set(arr)];
    console.log(res);

交集

    let res = [...new Set(arr)].filter(item => {
        let s2 = new Set(arr2);//4 5 6
        if(s2.has(item)) return true;
        else return false;
    });
    let res = [...new Set(arr)].filter(item => new Set(arr2).has(item));//简写
    console.log(res)

并集

 let res = [...new Set([...arr,...arr2])];
    console.log(res);

差集

let diff = [...new Set(arr)].filter(item => !(new Set(arr2).has(item)));
    console.log(diff);

手写的Set

function MySet(arr){
    let items = {};
    this.size = 0
    // has 方法
    this.has = function(val){
        // hasOwnProperty:实例obj是否包含有圆括号中的属性,是则返回true,否则是false
        return items.hasOwnProperty(val)
    }
    // add方法
    this.add = function(val){
      if(!this.has(val)){
        items[val] = val

        this.size++

        return true
      }  
    //   没有就返回false
      return false
    }
    // 遍历数组将每一项加入
    arr.forEach( item=>{
        this.add(item)
    } )

   // delete方法
    this.delete = function(val){
        if(this.has(val)){
            delete items[val]
            this.size--
            return true
        }else{
            return false
        }
    }

    // clear方法
    this.clear = function(){
        items = {}
        this.size = 0
    }

    // keys方法
    this.keys = function(){
        return Object.keys(items)
    }

    // value 方法
    this.value = function(){
        return Object.values(items)
    }

    // forEach 方法
    this.forEach = function(fn,context = this){
        for(let i = 0; i<this.size;i++){
            let item = Object.keys(items)[i]
            fn.call(context,item,item,items)
        }
    }
    // 并集
    this.union = function(other){
        let union = new MySet()
        let values = this.values()
        for(let i = 0 ;i < values.length;i++){
            union.add(values[i])
        }
        values = other.values()
        for(let i = 0 ; i <values.length;i++){
            union.add(values[i])
        }
        return union
    }

    // 交集
    this.intersect = function (other) {
        let intersect = new Set()
        let values = this.values()
        for (let i = 0; i < values.length; i++) {
            if (other.has(values[i])) {
                intersect.add(values[i])
            }
        }
        return intersect
    };
    // 差集
    this.difference = function (other) {
        let difference = new Set();
        let values = this.values();
        for (let i = 0; i < values.length; i++) {
            if (!other.has(values[i])) {
                difference.add(values[i])
            }
        }
        return difference
    };
    // 子集
    this.subset = function(other) {
        if (this.size > other.size) {
            return false
        } else {
            let values = this.values();
            for (let i = 0; i < values.length; i++) {
                console.log(values[i])
                console.log(other.values())
                if (!other.has(values[i])) {
                    return false
                }
            }
            return true
        }
    }

}

加油加油！！

努力学习！！