set集合和map集合

ES6中新增的数据存储结构，不同的场景使用不同的集合去存储数据。

1 .set集合

1.1 创建

用于存储不重复的数据
创建set集合
```js
    const s1 = new Set(iterable)
    console.log(s1)
```

1.2 方法

实例方法：

1. add() 添加数据

2. has() 判断数据是否存在

3. delete() 删除数据，返回值为是否删除成功

4. clear() 清空集合

5. size 集合长度 只读

6. for...of forEach

const m = new MyMap([
            ["a",1],
            ["b",2]
        ])
        console.log(m)
        // const value = m.get("c")
        // console.log(value)
        // const val = m.delete("b")
        // console.log(val)
        // const val = m.has("b")
        // console.log(val)
        // m.forEach((a,b,c) => {
        //     console.log(a,b,c)
        // });
       const iter =  m[Symbol.iterator]()
       

class MyMap{
    constructor(iterator = []){
        if(typeof iterator[Symbol.iterator] !== "function"){
            throw new TypeError(`您所提供的${iterator}不是一个可迭代对象`)
        }
        this._datas = [];
        for (const item of iterator) {
            // item也是一个可迭代对象
            if(typeof item[Symbol.iterator] !== "function"){
                throw new TypeError(`您所提供的${item}不是一个可迭代对象`)
            }
            // this.set(item[0],item[1])
            const iterator = item[Symbol.iterator]()//["a",1]
            const key = iterator.next().value
            const value = iterator.next().value
            this.set(key,value)
        }
    }
    set(key,value){
        // console.log(key,value)
        const obj = this._getObj(key)//undefined  item
        if(obj){
            obj.value = value
        }else{
            this._datas.push({
                key : key,
                value : value
            })
        }
    }
    _getObj(key){
        // 判断键名是否重复
        for (const item of this._datas) {
            if(this.isEqual(key,item.key)){
                return item
            }
        }
    }
    isEqual(data1,data2){
        if(data1 === 0 && data2 === 0){
            return true
        }
        return Object.is(data1,data2)
    }
    get(key){
        const obj = this._getObj(key)//undefined {"b":2}
        if(obj){
            return obj.value
        }
        return undefined
    }
    get size(){
        return this._datas.length;
    }
    delete(key){
        for(let i = 0;i<this._datas.length;i++){
            const element = this._datas[i]
            if(this.isEqual(key,element.key)){
                this._datas.splice(i,1)
                return true
            }
        }
        return false
    }
    clear(){
        this._datas.length = 0;
    }
    has(key){
        return this._getObj(key) !== undefined;
    }
    forEach(callback){
        for (const item of this._datas) {
            callback(item.value,item.key,this)
        }
    }
    *[Symbol.iterator](){
        for (const item of this._datas) {
            yield [item.key,item.value]
        }
    }
}

2. map集合

2.1 创建

以键值对的形式存储，存储键名不重复的数据
```js
    const map = new Map(iterable)
    console.log(map)
````

2.2 方法

实例方法：

1. size 集合长度 只读

2. set(键名，键值) 添加数据

3. get(键名) 获取数据

4. has() 判断数据是否存在

5. delete() 删除数据，返回值为是否删除成功

6. clear() 清空集合

7. for...of forEach

 const s = new MySet([1,2,3])
        // s.add(4)
        // s.add(4)
        console.log(s)
        // s.delete(3)
        // s.forEach((item,i,s) => {
        //     console.log(item,i,s)
        // });
        const iter = s[Symbol.iterator]()

class MySet{
    constructor(iterator = []){
        // 传递的内容必须是一个可迭代对象
        if(typeof iterator[Symbol.iterator] !== "function"){
            throw new TypeError(`您所提供的${iterator}不是一个可迭代对象`)
        }
        this._datas = [];
        for (const item of iterator) {
            // console.log(item)
            this.add(item)
        }
    }
    add(data){
        if(!this.has(data)){
            this._datas.push(data)
        }
    }
    has(data){
        for (const item of this._datas) {
            if(this.isEqual(data,item)){
                return true
            }
        }
        return false;
    }
    delete(data){
        for(let i = 0 ;i < this._datas.length;i++){
            const element = this._datas[i]
            if(this.isEqual(data,element)){
                this._datas.splice(i,1)
                return true
            }
        }
        return false
    }
    clear(){
        this._datas.length = 0
    }
    get size(){
        return this._datas.length
    }
    forEach(callback){
        for (const item of this._datas) {
            callback(item,item,this)
        }
    }
    *[Symbol.iterator](){
        for (const item of this._datas) {
            yield item
        }
    }
    isEqual(data1,data2){
        if(data1 === 0 && data2 === 0){
            return true
        }
        return Object.is(data1,data2)
    }
}