理解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<string, Array<ISquareCoordinate>> {
/**
* 重写 set 方法，将对象键序列化为字符串
* @param k 作为键的对象
* @param v 存储的值
* @returns Map实例
*/
set(k: ISquareCoordinate, v: Array<ISquareCoordinate>): this {
const stringifiedKey = JSON.stringify(k);
return super.set(stringifiedKey, v);
}
/**
* 重写 get 方法，将对象键序列化为字符串进行查找
* @param k 作为键的对象
* @returns 对应的值，如果不存在则为 undefined
*/
get(k: ISquareCoordinate): Array<ISquareCoordinate> | 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免费学习笔记（深入）”；
一个常见的错误是先将父类的生成器迭代器转换为数组，然后再处理数组：
// 这种方式效率低下，应避免
* keys() {
const keysArr = [...super.keys()]; // 将所有键加载到内存中
for (const key of keysArr) {
yield JSON.parse(key);
}
}这种做法的问题在于，[...super.keys()]会立即迭代并收集Map中所有的键，将其存储在一个数组中。对于包含大量数据的Map来说，这会消耗大量的内存，并丧失了生成器按需生成、惰性求值的优势。
正确的做法是直接迭代父类的生成器，并按需处理每个元素，从而保持迭代器的惰性：
class CoordMapper extends Map<string, Array<ISquareCoordinate>> {
// ... (set, get, has, delete 方法如上)
/**
* 重写 keys() 生成器，返回反序列化后的对象键
*/
* keys(): Generator<ISquareCoordinate, void, unknown> {
const parentKeyIterator = super.keys(); // 获取父类的键迭代器
for (const stringifiedKey of parentKeyIterator) {
yield JSON.parse(stringifiedKey); // 按需反序列化并生成
}
}
/**
* 重写 values() 生成器，直接返回父类的值
*/
* values(): Generator<Array<ISquareCoordinate>, void, unknown> {
yield* super.values(); // 使用 yield* 委托给父类迭代器
}
/**
* 重写 entries() 生成器，返回反序列化后的键和对应的值
*/
* entries(): Generator<[ISquareCoordinate, Array<ISquareCoordinate>], 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出结果，保持了生成器的惰性特性，避免了不必要的内存开销。
注意事项与局限性
- JSON.stringify/JSON.parse的性能开销： 频繁地进行字符串化和反序列化操作会带来一定的性能开销，特别是对于大型或复杂的对象。在性能敏感的场景下，需要权衡这种开销。
-
JSON.stringify的局限性：
- 它无法序列化函数、undefined、Symbol值，它们在序列化后会被忽略或转换为null。
- 它无法处理循环引用，会导致抛出错误。
- 它不保证对象属性的顺序，但通常对于作为键的对象，属性顺序不影响其逻辑等价性。
- 它不能处理Date对象（会转换为ISO字符串）或RegExp对象（会转换为空对象）。
- 替代方案： 如果JSON.stringify不适用，可以考虑实现一个自定义的哈希函数，将对象映射到一个唯一的字符串或数字哈希值作为内部Map的键。这通常更复杂，但提供了更大的灵活性和控制。
- 类型安全： 在TypeScript中，确保重写方法的类型签名与父类兼容，并正确处理反序列化后的类型。
总结
通过扩展JavaScript的Map类，并结合JSON.stringify/JSON.parse，我们可以实现基于对象内容而非引用的键比较机制，从而满足特定的数据存储需求。在重写keys()、values()和entries()等生成器方法时，关键在于直接迭代父类的生成器，并按需处理每个元素，以保持迭代器的惰性特性，避免不必要的内存消耗和性能下降。理解这些细节对于构建高效且功能强大的自定义数据结构至关重要。
