首页 数据结构

# 字典

❑ set (key, value)：向字典中添加新元素。如果 key 已经存在，那么已存在的 value 会被新的值覆盖。
❑ remove (key)：通过使用键值作为参数来从字典中移除键值对应的数据值。
❑ hasKey (key)：如果某个键值存在于该字典中，返回 true，否则返回 false。
❑ get (key)：通过以键值作为参数查找特定的数值并返回。
❑ clear ()：删除该字典中的所有值。
❑ size ()：返回字典所包含值的数量。与数组的 length 属性类似。
❑ isEmpty ()：在 size 等于零的时候返回 true，否则返回 false。
❑ keys ()：将字典所包含的所有键名以数组形式返回。
❑ values ()：将字典所包含的所有数值以数组形式返回。
❑ keyValues ()：将字典中所有 [键，值] 对返回。
❑ forEach (callbackFn)：迭代字典中所有的键值对。callbackFn 有两个参数：key 和 value。该方法可以在回调函数返回 false 时被中止（和 Array 类中的 every 方法相似）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
const myToString = function (item) {
    if (item === null) {
        return "NULL";
    } else if (item === undefined) {
        return "UNDEFINED";
    } else if (typeof item === "string" || item instanceof String) {
        return `${item}`;
    }
    return item.toString();
};

class ValuePair {
    constructor(key, value) {
        this.key = key;
        this.value = value;
    }
    toString() {
        return `[#${this.key}: ${this.value}]`;
    }
}

class myMap {
    constructor(toStr = myToString) {
        this.toStr = toStr;
        this.table = [];
    }

    hasKey(key) {
        return this.table[this.toStr(key)] != null;
    }
    set(key, value) {
        if (key != null && value != null) {
            const tableKey = this.toStr(key); // {1}
            this.table[tableKey] = new ValuePair(key, value); // {2}
            return true;
        }
        return false;
    }

    get(key) {
        const valuePair = this.table[this.toStr(key)]; // {1}
        return valuePair == null ? undefined : valuePair.value; // {2}
    }

    remove(key) {
        if (this.hasKey(key)) {
            delete this.table[this.toStr(key)];
            return true;
        }
        0;
        return false;
    }

    keyValues() {
        return Object.values(this.table);
    }

    keys() {
        return this.keyValues().map((valuePair) => valuePair.key);
    }

    values() {
        return this.keyValues().map((valuePair) => valuePair.value);
    }

    forEach(callbackFn) {
        const valuePairs = this.keyValues(); // {1}
        for (let i = 0; i < valuePairs.length; i++) {
            // {2}
            const result = callbackFn(valuePairs[i].key, valuePairs[i].value); // {3}
            if (result === false) {
                break; // {4}
            }
        }
    }

    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()}`; // {1}
        for (let i = 1; i < valuePairs.length; i++) {
            objString = `${objString}, ${valuePairs[i].toString()}`; // {2}
        }
        return objString; // {3}
    }
}