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

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() {
   const keysArr = [...super.keys()]; // 将所有键加载到内存中
   for (const key of keysArr) {
      yield JSON.parse(key);
   }
}

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]; // 按需反序列化键并生成键值对
        }
    }
}