Map知识点和手写模拟Map对象

左手的ㄟ右手 2023-07-19 10:48 32阅读 0赞

`Map集合`存储的二维数组的的是键值对

const map = new Map([
        ["name", "robbit"],
        ["age", 20]
    ])
    console.log(map)
    
    // Map(2) {"name" => "roobit", "age" => 20}

**get(key)** 返回`Map集合`中`key`的`val`值

map.get('name') // robbit

**set(key,val)** 设置`Map集合`的数据

map.set('money', 0.01)
    console.log(map)
    
    // Map(3) {"name" => "robbit", "age" => 20, "money" => 0.01}

`size` 和 `Set对象`一样，保存着`Map集合`的长度

console.log(map.size) // 3

**has(key)** 判断`Map集合`中是否存在`key`值

map.has('name') // true

**delete(key)** 删除`Map集合`中`key`值，返回`Boolean`值

map.delete('money')  // true
    console.log(map) // Map(2) {"name" => "robbit", "age" => 20}

**clear()** 清空`Map集合`中的值

map.clear() // Map(0) {}

**forEach()** 遍历`Map集合`

for (const [key, value] of map) {  //解构
        console.log(key, value)
    }
    
    map.forEach((value, key, map) => { 
        console.log(value, key, map)
    })

**手写模拟MyMap集合**

class MyMap { 
        constructor(iterable) { 
            if (typeof iterable[Symbol.iterator] !== 'function') { 
                throw new TypeError(`您所提供的${ iterable}不是一个可迭代对象`);
            }
            this._datas = [];
            for (let item of iterable) { 
                if (typeof item[Symbol.iterator] !== 'function') { 
                    throw new TypeError(`您所提供的${ iterable}不是一个可迭代对象`);
                }
                const iterator = item[Symbol.iterator]();
                const key = iterator.next().value;
                const value = iterator.next().value;
                this.set(key, value);
            }
        }
    
        get size() { 
            return this._datas.length;
        }
    
        set(key, value) { 
            const item = this._getObj(key);
    
            if (item) { 
                item.value = value
            } else { 
                this._datas.push({ 
                    key,
                    value
                })
            }
        }
    
        get(key) { 
            const item = this._getObj(key);
            if (item) { 
                return item.value;
            }
            return undefined;
        }
    
        delete(key) { 
            for (let i = 0; i < this._datas.length; i++) { 
                if (this.isEqual(key, this._datas[i].key)) { 
                    this._datas.splice(i, 1);
                    return true
                }
            }
            return false;
        }
    
        clear() { 
            this._datas.length = 0;
            return true;
        }
    
        has(key) { 
            return this._getObj(key) !== undefined;
        }
    
        _getObj(key) { 
            for (const item of this._datas) { 
                if (this.isEqual(item.key, key)) { 
                    return item;
                }
            }
        }
    
        isEqual(data1, data2) { 
            if (data1 === 0 && data2 === 0) { 
                return true;
            }
            return Object.is(data1, data2)
        }
    
        forEach(callback) { 
            for (const item of this._datas) { 
                callback(item.value, item.key, this)
            }
        }
    }