字典map

Posted 2021-08-11 XTTX

字典

字典和集合很相似，集合以[值，值]的形式存储元素，字典则是以[键，值]的形式来存储元素

实现Dictionary

function defaultToString(item){
    // 将键转化为字符串
    if(item === null){
        return \'NULL\'
    }else if(item === undefined){
        return \'UNDEFINED\'
    }else{
        return item.toString()
    }

}

class valuePair{
　　 // 键值对
    constructor(key, value){
        this.key = key
        this.value = value
    }
    toString(){
        return `[#${this.key}: ${this.value}]`
    }
}

class Dictionary{
    constructor(toStrFn = defaultToString){
        this.toStrFn = toStrFn  // 键转化为字符串
        this.table = {}
    }
    hasKey(key){
        return this.table[this.toStrFn[key]] !== undefined
    }
    set(key, val){
        // 添加新元素
        if(key !== null && val !== null){
            const strKey = this.toStrFn(key)
            this.table[strKey] = new valuePair(key, val)
            return true
        }
        return false
    }
    remove(key){
        if (this.hasKey(key)) {
            delete this.table[this.toStrFn(key)]
            return true
        }
        return false
    }
    get(key){
        const value = this.table[this.toStrFn(key)]
        return value === undefined ? null : value.value
    }
    keyValues(){
        // 返回所有键值对组成的数组
        // Object.values(obj): Returns an array of values of the enumerable properties of an object
        return Object.values(this.table)
    }
    keys(){
        // 返回所有键组成的数组
        return this.keyValues().map((val) => {
            return val.key
        })
    }
    values(){
        // 返回所有值组成的数组
        return this.keyValues().map((val) => {
            return val.value
        })
    }
    forEach(callbackFn){
        // 传入一个函数,参数为(key, value),迭代数组中的每个键值对运行
        const valuePair = this.keyValues()
        for(let i=0; i<valuePair.length; i++){
            const result = callbackFn(valuePair[i].key, valuePair[i].value)
            if (result === false) {
                break   // 出错立即停止
            }
        }
    }
    size(){
        return Object.keys(this.table).length
    }
    isEmpty(){
        return this.size() === 0
    }
    clear(){
        this.table = {}
    }
    toString(){
        if(this.isEmpty()){
            return ""
        }
        const valuePairs = this.keyValues()
        let objString = `${valuePairs[0].toString()}`
        for(let i=1; i<this.size(); i++){
            objString = `${objString},${valuePairs[i].toString()}`
        }
        return objString
    }
}

原生Map类

const map = new Map()
map.set("a","aa")
map.set("b","bb")
map.set("c","cc")

console.log(map.has("b"))   // true
console.log(map.size)       // 3

// 和我们定义的 Dictionary 类不同，ES2015 的 Map 类的 values 方法和 keys 方法都返回Iterator
console.log(map.keys())     // [Map Iterator] { \'a\', \'b\', \'c\' }
console.log(map.values())   // [Map Iterator] { \'aa\', \'bb\', \'cc\' }

console.log(map.get("c"))   // cc
map.delete(\'c\')  // 删除

WeakMap 和 WeakSet

除了 Set 和 Map 这两种新的数据结构，ES2015还增加了它们的弱化版本，WeakSet 和 WeakMap

基本上，Map 和 Set 与其弱化版本之间仅有的区别是：

　　1. WeakSet 或 WeakMap 类没有 entries、keys 和 values 等方法

　　2. 只能用对象作为键。

创建和使用这两个类主要是为了性能。WeakSet 和 WeakMap 是弱化的（用对象作为键），没有强引用的键，这使得 javascript 的垃圾回收器可以从中清除整个入口。

另一个优点是，必须用键才可以取出值，这些类没有 entries、keys 和 values 等迭代器方法，因此，除非你知道键，否则没有办法取出值，所以可以使用WeakMap类封装私有属性。

// 例：
const weakMap = new WeakMap()
const obj1 = {"name": "1"}
const obj2 = {"name": "2"}
const obj3 = {"name": "3"}

map.set(obj1, "111")
map.set(obj2, "222")
map.set(obj3, "333")

console.log(map.has(obj1))      // true
console.log(map.get(obj3))      // 333
map.delete(obj2)                // 删除