JavaScript Map类扩展：实现对象值比较键与优化生成器方法

理解JavaScript Map的键比较机制

javascript的map对象在处理键时，默认使用严格相等（===）进行比较。这意味着对于原始类型（如字符串、数字、布尔值），它们的值相等即被认为是同一个键。然而，对于非原始类型（如对象、数组），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 (因为引用不同，尽管内容相同)

在某些场景下，我们可能希望Map能够根据对象的内容（值）而不是引用来判断键是否相同。例如，当我们需要将坐标对象{x:1, y:2}作为键，并希望{x:1, y:2}（即使是不同的实例）能检索到相同的值时，就需要自定义Map的行为。

扩展Map实现基于值比较的键

为了实现基于对象值的键比较，一种常见的方法是在存储和检索键时，将对象转换为其字符串表示形式。JSON.stringify()是一个常用的工具，可以将JavaScript对象转换为JSON字符串。我们可以通过扩展Map类并重写其set和get方法来实现这一点：

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

class CoordMapper extends Map> {
    /**
     * 重写 set 方法，将对象键序列化为字符串
     * @param k 作为键的对象
     * @param v 存储的值
     * @returns Map实例
     */
    set(k: ISquareCoordinate, v: Array): this {
        const stringifiedKey = JSON.stringify(k);
        return super.set(stringifiedKey, v);
    }

    /**
     * 重写 get 方法，将对象键序列化为字符串进行查找
     * @param k 作为键的对象
     * @returns 对应的值，如果不存在则为 undefined
     */
    get(k: ISquareCoordinate): Array | undefined {
        const stringifiedKey = JSON.stringify(k);
        return super.get(stringifiedKey);
    }

    /**
     * 重写 has 方法，将对象键序列化为字符串进行判断
     * @param k 作为键的对象
     * @returns boolean
     */
    has(k: ISquareCoordinate): boolean {
        const stringifiedKey = JSON.stringify(k);
        return super.has(stringifiedKey);
    }

    /**
     * 重写 delete 方法，将对象键序列化为字符串进行删除
     * @param k 作为键的对象
     * @returns boolean
     */
    delete(k: ISquareCoordinate): boolean {
        const stringifiedKey = JSON.stringify(k);
        return super.delete(stringifiedKey);
    }
}

现在，CoordMapper实例将根据对象的值来处理键：

const mapper = new CoordMapper();
const coord1 = { x: 1, y: 2 };
const coord2 = { x: 1, y: 2 }; // 内容与coord1相同，但引用不同

mapper.set(coord1, [{ x: 3, y: 4 }]);
console.log(mapper.get(coord1)); // 输出: [{ x: 3, y: 4 }]
console.log(mapper.get(coord2)); // 输出: [{ x: 3, y: 4 }] (现在可以正确获取)

高效地扩展生成器方法（keys(), values(), entries()）

Map类提供了keys()、values()和entries()等生成器方法，它们返回迭代器，允许我们按需遍历键、值或键值对。当我们扩展Map并修改了键的内部表示（如字符串化）后，这些生成器方法也需要被重写，以返回原始的、反序列化后的对象键。

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

一个常见的错误是先将父类的生成器迭代器转换为数组，然后再处理数组：

Dora

创建令人惊叹的3D动画网站，无需编写一行代码。

下载

// 这种方式效率低下，应避免
* keys() {
   const keysArr = [...super.keys()]; // 将所有键加载到内存中
   for (const key of keysArr) {
      yield JSON.parse(key);
   }
}

这种做法的问题在于，[...super.keys()]会立即迭代并收集Map中所有的键，将其存储在一个数组中。对于包含大量数据的Map来说，这会消耗大量的内存，并丧失了生成器按需生成、惰性求值的优势。

正确的做法是直接迭代父类的生成器，并按需处理每个元素，从而保持迭代器的惰性：

class CoordMapper extends Map> {
    // ... (set, get, has, delete 方法如上)

    /**
     * 重写 keys() 生成器，返回反序列化后的对象键
     */
    * keys(): Generator {
        const parentKeyIterator = super.keys(); // 获取父类的键迭代器
        for (const stringifiedKey of parentKeyIterator) {
            yield JSON.parse(stringifiedKey); // 按需反序列化并生成
        }
    }

    /**
     * 重写 values() 生成器，直接返回父类的值
     */
    * values(): Generator, void, unknown> {
        yield* super.values(); // 使用 yield* 委托给父类迭代器
    }

    /**
     * 重写 entries() 生成器，返回反序列化后的键和对应的值
     */
    * entries(): Generator<[ISquareCoordinate, Array], void, unknown> {
        const parentEntryIterator = super.entries(); // 获取父类的键值对迭代器
        for (const [stringifiedKey, value] of parentEntryIterator) {
            yield [JSON.parse(stringifiedKey), value]; // 按需反序列化键并生成键值对
        }
    }
}

通过这种方式，每次调用我们自定义的keys()、values()或entries()迭代器的next()方法时，它会相应地调用super.keys()、super.values()或super.entries()的next()方法一次，然后处理并yield出结果，保持了生成器的惰性特性，避免了不必要的内存开销。

注意事项与局限性

1. JSON.stringify/JSON.parse的性能开销： 频繁地进行字符串化和反序列化操作会带来一定的性能开销，特别是对于大型或复杂的对象。在性能敏感的场景下，需要权衡这种开销。
2. JSON.stringify的局限性：
   • 它无法序列化函数、undefined、Symbol值，它们在序列化后会被忽略或转换为null。
   • 它无法处理循环引用，会导致抛出错误。
   • 它不保证对象属性的顺序，但通常对于作为键的对象，属性顺序不影响其逻辑等价性。
   • 它不能处理Date对象（会转换为ISO字符串）或RegExp对象（会转换为空对象）。
3. 替代方案： 如果JSON.stringify不适用，可以考虑实现一个自定义的哈希函数，将对象映射到一个唯一的字符串或数字哈希值作为内部Map的键。这通常更复杂，但提供了更大的灵活性和控制。
4. 类型安全： 在TypeScript中，确保重写方法的类型签名与父类兼容，并正确处理反序列化后的类型。

总结

通过扩展JavaScript的Map类，并结合JSON.stringify/JSON.parse，我们可以实现基于对象内容而非引用的键比较机制，从而满足特定的数据存储需求。在重写keys()、values()和entries()等生成器方法时，关键在于直接迭代父类的生成器，并按需处理每个元素，以保持迭代器的惰性特性，避免不必要的内存消耗和性能下降。理解这些细节对于构建高效且功能强大的自定义数据结构至关重要。