扩展JavaScript Map实现基于内容的对象键管理及生成器方法优化

JavaScript Map的默认行为：基于引用的对象键

在javascript中，map对象提供了一种存储键值对的强大机制。然而，当使用对象作为键时，map默认采用的是引用相等性（reference equality）来判断键是否相同。这意味着，即使两个对象拥有完全相同的属性和值，只要它们在内存中是不同的实例，map就会将它们视为不同的键。

考虑以下示例：

let newMap = new Map();
const obj1 = {'a': 1, 'b' :2};
newMap.set(obj1, 123);

const copyObj1 = {...obj1}; // 创建一个与obj1内容相同但引用不同的新对象

console.log(newMap.get(obj1));      // 输出: 123 (因为是同一个引用)
console.log(newMap.get(copyObj1));  // 输出: undefined (因为引用不同)

在这个例子中，尽管 obj1 和 copyObj1 的内容完全一致，newMap.get(copyObj1) 却返回 undefined，因为 Map 比较的是它们的内存地址，而非其内部结构。在某些应用场景中，我们可能需要基于对象内容来识别键，这就需要对Map的行为进行扩展。

实现基于内容的对象键

要实现基于内容的对象键，核心策略是将对象键序列化为字符串。当设置或获取键时，我们首先将对象转换为一个唯一的字符串表示，然后使用这个字符串作为Map的实际键。最常用的序列化方法是 JSON.stringify()。

扩展Map的set和get方法

我们可以通过继承Map类并重写其set和get方法来实现这一功能。以下是一个示例：

立即学习“Java免费学习笔记（深入）”；

interface ISquareCoordinate {
    x: number;
    y: number;
}

class ContentBasedMap extends Map {
    /**
     * 设置键值对。键K会被序列化为字符串。
     * @param k 原始对象键
     * @param v 对应的值
     * @returns 当前Map实例
     */
    set(k: K, v: V): this {
        const stringifiedKey = JSON.stringify(k);
        return super.set(stringifiedKey, v);
    }

    /**
     * 根据对象键获取对应的值。键K会被序列化为字符串。
     * @param k 原始对象键
     * @returns 对应的值，如果不存在则为undefined
     */
    get(k: K): V | undefined {
        const stringifiedKey = JSON.stringify(k);
        return super.get(stringifiedKey);
    }

    /**
     * 检查Map中是否存在指定键。键K会被序列化为字符串。
     * @param k 原始对象键
     * @returns 如果键存在则为true，否则为false
     */
    has(k: K): boolean {
        const stringifiedKey = JSON.stringify(k);
        return super.has(stringifiedKey);
    }

    /**
     * 删除Map中指定的键。键K会被序列化为字符串。
     * @param k 原始对象键
     * @returns 如果成功删除则为true，否则为false
     */
    delete(k: K): boolean {
        const stringifiedKey = JSON.stringify(k);
        return super.delete(stringifiedKey);
    }
}

在这个ContentBasedMap类中，set和get方法在内部将传入的对象键 k 通过 JSON.stringify(k) 转换为字符串，然后调用父类 Map 的相应方法。这样，Map内部实际存储的是字符串键，从而实现了基于内容的对象比较。

优化生成器方法：keys(), values(), entries()

Map类提供了 keys()、values() 和 entries() 等生成器方法，它们返回迭代器，允许我们按需遍历键、值或键值对，而无需一次性加载所有数据到内存中，这对于处理大量数据非常高效。当我们扩展Map并使用字符串化键时，这些生成器方法返回的键也是字符串。我们需要将它们反序列化回原始对象形式，同时保留生成器的懒加载特性。

生成器方法的挑战

一个常见的错误做法是在重写生成器方法时，将父类的迭代器完全展开成一个数组，然后再进行处理。例如：

// 错误示例：丧失懒加载特性
* keys(): Generator {
   const keysArr = [...super.keys()]; // 这会一次性加载所有键到内存
   for (const key of keysArr){
      yield JSON.parse(key);
   }
}

这种方法虽然能达到反序列化的目的，但它会一次性迭代并收集所有父类的键到 keysArr 数组中，从而丧失了生成器方法的懒加载（lazy evaluation）优势。如果Map中包含大量数据，这可能导致显著的内存消耗和性能问题。

Vozo

Vozo是一款强大的AI视频编辑工具，可以帮助用户轻松重写、配音和编辑视频。

下载

正确实现keys()生成器

为了在反序列化键的同时保留懒加载特性，我们应该直接迭代父类的生成器，并在每次迭代时对键进行反序列化并 yield 出去：

class ContentBasedMap extends Map {
    // ... (set, get, has, delete 方法与上文相同)

    /**
     * 返回一个迭代器，按插入顺序遍历Map中的所有原始对象键。
     * 保持生成器的懒加载特性。
     * @returns 原始对象键的迭代器
     */
    * keys(): Generator {
        const parentKeyIterator = super.keys(); // 获取父类的键迭代器
        for (const stringifiedKey of parentKeyIterator) {
            yield JSON.parse(stringifiedKey) as K; // 逐个反序列化并yield
        }
    }
}

通过这种方式，ContentBasedMap的keys()方法每次被调用 next() 时，它会调用 super.keys() 的 next() 方法一次，获取一个字符串化的键，然后立即对其进行 JSON.parse 反序列化，并将结果 yield 出去。这样，数据流是按需进行的，完全保留了生成器的懒加载优势。

values()和entries()的类似处理

同样的原则也适用于 values() 和 entries() 方法。values() 返回的是原始值，通常不需要反序列化（除非值本身也是需要特殊处理的序列化对象）。entries() 返回键值对，其中键需要反序列化。

class ContentBasedMap extends Map {
    // ... (set, get, has, delete, keys 方法与上文相同)

    /**
     * 返回一个迭代器，按插入顺序遍历Map中的所有原始值。
     * @returns 值的迭代器
     */
    * values(): Generator {
        // 如果值不需要特殊处理，直接迭代父类values即可
        yield* super.values();
    }

    /**
     * 返回一个迭代器，按插入顺序遍历Map中的所有原始键值对。
     * 键会被反序列化回原始对象形式。
     * @returns 原始键值对的迭代器
     */
    * entries(): Generator<[K, V], void, unknown> {
        const parentEntryIterator = super.entries();
        for (const [stringifiedKey, value] of parentEntryIterator) {
            yield [JSON.parse(stringifiedKey) as K, value];
        }
    }

    // 实现Symbol.iterator以使Map实例可直接用for...of遍历
    [Symbol.iterator](): Generator<[K, V], void, unknown> {
        return this.entries();
    }
}

完整示例：ContentBasedMap类

将所有优化后的方法整合，我们可以得到一个功能完整的 ContentBasedMap 类：

interface ISquareCoordinate {
    x: number;
    y: number;
}

class ContentBasedMap extends Map {
    set(k: K, v: V): this {
        const stringifiedKey = JSON.stringify(k);
        return super.set(stringifiedKey, v);
    }

    get(k: K): V | undefined {
        const stringifiedKey = JSON.stringify(k);
        return super.get(stringifiedKey);
    }

    has(k: K): boolean {
        const stringifiedKey = JSON.stringify(k);
        return super.has(stringifiedKey);
    }

    delete(k: K): boolean {
        const stringifiedKey = JSON.stringify(k);
        return super.delete(stringifiedKey);
    }

    * keys(): Generator {
        const parentKeyIterator = super.keys();
        for (const stringifiedKey of parentKeyIterator) {
            yield JSON.parse(stringifiedKey) as K;
        }
    }

    * values(): Generator {
        yield* super.values(); // 直接委托给父类迭代器
    }

    * entries(): Generator<[K, V], void, unknown> {
        const parentEntryIterator = super.entries();
        for (const [stringifiedKey, value] of parentEntryIterator) {
            yield [JSON.parse(stringifiedKey) as K, value];
        }
    }

    // 使ContentBasedMap实例可直接用于for...of循环
    [Symbol.iterator](): Generator<[K, V], void, unknown> {
        return this.entries();
    }
}

// 使用示例
const myContentMap = new ContentBasedMap();

const coord1 = { x: 10, y: 20 };
const coord2 = { x: 30, y: 40 };
const coord1_copy = { x: 10, y: 20 };

myContentMap.set(coord1, "Location A");
myContentMap.set(coord2, "Location B");

console.log("Get coord1:", myContentMap.get(coord1));          // 输出: Location A
console.log("Get coord1_copy:", myContentMap.get(coord1_copy)); // 输出: Location A (基于内容匹配)
console.log("Has coord1_copy:", myContentMap.has(coord1_copy)); // 输出: true

console.log("\nIterating keys:");
for (const key of myContentMap.keys()) {
    console.log(key); // 输出原始对象 { x: 10, y: 20 }, { x: 30, y: 40 }
}

console.log("\nIterating entries:");
for (const [key, value] of myContentMap) { // 使用Symbol.iterator
    console.log(`Key: ${JSON.stringify(key)}, Value: ${value}`);
}

myContentMap.delete(coord1_copy); // 基于内容删除
console.log("After deleting coord1_copy, has coord1:", myContentMap.has(coord1)); // 输出: false

注意事项与最佳实践

在实现基于内容的Map时，有几个重要的考量点：

1. 性能开销：JSON.stringify()JSON.stringify() 操作本身需要时间和计算资源。对于非常大的对象、深度嵌套的对象或在高性能要求的场景下，频繁的序列化和反序列化可能会成为性能瓶颈。如果键对象结构简单且数量不大，这通常不是问题。

2. 键的确定性：JSON.stringify()的局限性JSON.stringify() 默认情况下对对象的属性顺序不敏感，但对于某些复杂的JavaScript对象（例如包含 undefined、函数、Symbol 或循环引用），它可能无法正确序列化，或者生成不确定性的字符串。

   • 属性顺序： 对于普通对象，JSON.stringify通常会按属性定义的顺序或键的字母顺序（在某些实现中）进行序列化。如果你的对象属性顺序不确定，且 JSON.stringify 行为不一致，可能导致逻辑上相同的对象产生不同的字符串。为了确保确定性，可以考虑在序列化前对对象属性进行排序，或者实现自定义的序列化函数。
   • 非JSON安全数据类型： JSON.stringify 会忽略 undefined、函数、Symbol 值，并且会把 Date 对象转换为 ISO 格式字符串。如果你的对象键包含这些类型，JSON.stringify 可能无法提供一个准确反映对象内容的唯一字符串。

3. 键的不可变性 一旦一个对象被用作 ContentBasedMap 的键，并被序列化存储，它的字符串表示就固定了。如果在之后修改了原始对象（例如 coord1.x = 99），Map 内部存储的字符串键不会随之更新。这意味着使用修改后的对象去 get 或 delete 将无法匹配，除非你再次 set 它。因此，作为键的对象应该被视为不可变的。

4. 替代方案 对于更复杂的对象比较逻辑或更高的性能要求，可以考虑：

   • 自定义哈希函数： 如果 JSON.stringify 不适用，可以实现一个自定义的哈希函数，将对象转换为一个唯一的哈希值（字符串或数字），然后用这个哈希值作为Map的键。
   • 第三方库： 某些库（如 lodash.isEqual）提供了深度比较对象的功能。结合这些库，可以实现一个 WeakMap 或一个自定义的 Map 包装器，通过比较对象内容来管理键。
   • WeakMap的局限性： WeakMap 只能使用对象作为键，且键是弱引用，但它同样是基于引用比较的。

总结

通过扩展JavaScript Map类并重写其核心方法，我们可以实现基于对象内容而非引用的键管理，这在许多需要结构化数据作为键的场景中非常有用。关键在于使用 JSON.stringify() 对键进行序列化，并在处理 keys()、values() 和 entries() 等生成器方法时，通过直接迭代父类迭代器并按需反序列化，以保留其懒加载特性，从而避免不必要的性能开销和内存消耗。在实施此类扩展时，务必考虑 JSON.stringify() 的局限性、键的不可变性以及潜在的性能影响，并根据具体需求选择最合适的实现方案。