扩展JavaScript 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 (因为引用不同)

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);
    }
}

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

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
        }
    }
}

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();
    }
}

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