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<K extends object, V> extends Map<string, V> {
/**
* 设置键值对。键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<K, void, unknown> {
const keysArr = [...super.keys()]; // 这会一次性加载所有键到内存
for (const key of keysArr){
yield JSON.parse(key);
}
}这种方法虽然能达到反序列化的目的，但它会一次性迭代并收集所有父类的键到 keysArr 数组中，从而丧失了生成器方法的懒加载（lazy evaluation）优势。如果Map中包含大量数据，这可能导致显著的内存消耗和性能问题。
正确实现keys()生成器
为了在反序列化键的同时保留懒加载特性，我们应该直接迭代父类的生成器，并在每次迭代时对键进行反序列化并 yield 出去：
class ContentBasedMap<K extends object, V> extends Map<string, V> {
// ... (set, get, has, delete 方法与上文相同)
/**
* 返回一个迭代器，按插入顺序遍历Map中的所有原始对象键。
* 保持生成器的懒加载特性。
* @returns 原始对象键的迭代器
*/
* keys(): Generator<K, void, unknown> {
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<K extends object, V> extends Map<string, V> {
// ... (set, get, has, delete, keys 方法与上文相同)
/**
* 返回一个迭代器，按插入顺序遍历Map中的所有原始值。
* @returns 值的迭代器
*/
* values(): Generator<V, void, unknown> {
// 如果值不需要特殊处理，直接迭代父类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<K extends object, V> extends Map<string, V> {
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<K, void, unknown> {
const parentKeyIterator = super.keys();
for (const stringifiedKey of parentKeyIterator) {
yield JSON.parse(stringifiedKey) as K;
}
}
* values(): Generator<V, void, unknown> {
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<ISquareCoordinate, string>();
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时，有几个重要的考量点：
性能开销：JSON.stringify()JSON.stringify() 操作本身需要时间和计算资源。对于非常大的对象、深度嵌套的对象或在高性能要求的场景下，频繁的序列化和反序列化可能会成为性能瓶颈。如果键对象结构简单且数量不大，这通常不是问题。
-
键的确定性：JSON.stringify()的局限性JSON.stringify() 默认情况下对对象的属性顺序不敏感，但对于某些复杂的JavaScript对象（例如包含 undefined、函数、Symbol 或循环引用），它可能无法正确序列化，或者生成不确定性的字符串。
- 属性顺序： 对于普通对象，JSON.stringify通常会按属性定义的顺序或键的字母顺序（在某些实现中）进行序列化。如果你的对象属性顺序不确定，且 JSON.stringify 行为不一致，可能导致逻辑上相同的对象产生不同的字符串。为了确保确定性，可以考虑在序列化前对对象属性进行排序，或者实现自定义的序列化函数。
- 非JSON安全数据类型： JSON.stringify 会忽略 undefined、函数、Symbol 值，并且会把 Date 对象转换为 ISO 格式字符串。如果你的对象键包含这些类型，JSON.stringify 可能无法提供一个准确反映对象内容的唯一字符串。
键的不可变性 一旦一个对象被用作 ContentBasedMap 的键，并被序列化存储，它的字符串表示就固定了。如果在之后修改了原始对象（例如 coord1.x = 99），Map 内部存储的字符串键不会随之更新。这意味着使用修改后的对象去 get 或 delete 将无法匹配，除非你再次 set 它。因此，作为键的对象应该被视为不可变的。
-
替代方案 对于更复杂的对象比较逻辑或更高的性能要求，可以考虑：
- 自定义哈希函数： 如果 JSON.stringify 不适用，可以实现一个自定义的哈希函数，将对象转换为一个唯一的哈希值（字符串或数字），然后用这个哈希值作为Map的键。
- 第三方库： 某些库（如 lodash.isEqual）提供了深度比较对象的功能。结合这些库，可以实现一个 WeakMap 或一个自定义的 Map 包装器，通过比较对象内容来管理键。
- WeakMap的局限性： WeakMap 只能使用对象作为键，且键是弱引用，但它同样是基于引用比较的。
总结
通过扩展JavaScript Map类并重写其核心方法，我们可以实现基于对象内容而非引用的键管理，这在许多需要结构化数据作为键的场景中非常有用。关键在于使用 JSON.stringify() 对键进行序列化，并在处理 keys()、values() 和 entries() 等生成器方法时，通过直接迭代父类迭代器并按需反序列化，以保留其懒加载特性，从而避免不必要的性能开销和内存消耗。在实施此类扩展时，务必考虑 JSON.stringify() 的局限性、键的不可变性以及潜在的性能影响，并根据具体需求选择最合适的实现方案。
