优化JavaScript对象中数组元素迁移的策略：双向映射数据结构

let obj = {
  22: [7, 4, 2, 3],
  23: [1, 5, 6],
};

{
  22: [7, 4, 2],
  23: [1, 5, 6, 3],
}

let change = { key: 23, value: 3 }; // 目标：将值3移动到键23
let obj = {
  22: [7, 4, 2, 3],
  23: [1, 5, 6],
};

// 查找值3当前所在的键
let fromKey = Object.keys(obj).find((key) => obj[key].includes(change.value));

if (fromKey) {
  // 从原数组中移除值3
  obj[fromKey] = obj[fromKey].filter((item) => item !== change.value);
}

// 将值3添加到目标键的数组中
obj[change.key].push(change.value);

console.log(obj);
/*
输出：
{
  22: [7, 4, 2],
  23: [1, 5, 6, 3],
}
*/

/**
 * Db 函数：创建一个管理键值对（值可移动）的数据结构。
 * 内部维护正向映射 (key -> Set<values>) 和反向映射 (value -> key)。
 * @returns {object} 包含 set 和 toObject 方法的对象。
 */
function Db() {
  // fwd: 正向映射，Map<键, Set<值>>
  const fwd = new Map();
  // rev: 反向映射，Map<值, 键>
  const rev = new Map();

  return {
    /**
     * set 方法：将一个值关联到指定的键。如果该值之前已存在于其他键下，则会将其移动。
     * @param {any} k - 目标键。
     * @param {any} v - 要关联的值。
     */
    set(k, v) {
      // 1. 检查值 v 是否已经存在于某个键下
      if (rev.has(v)) {
        const oldKey = rev.get(v); // 获取值 v 之前的键
        // 从旧键对应的 Set 中删除值 v
        // 确保 oldKey 对应的 Set 存在，并尝试删除 v
        if (fwd.has(oldKey)) {
          fwd.get(oldKey).delete(v);
          // 如果旧键对应的 Set 变为空，可以考虑删除该键，但非必须，此处不处理
          // if (fwd.get(oldKey).size === 0) {
          //   fwd.delete(oldKey);
          // }
        }
      }

      // 2. 更新反向映射：将值 v 与新键 k 关联
      rev.set(v, k);

      // 3. 更新正向映射：将值 v 添加到新键 k 对应的 Set 中
      if (fwd.has(k)) {
        // 如果键 k 已经存在，则将其对应的 Set 添加值 v
        fwd.get(k).add(v);
      } else {
        // 如果键 k 不存在，则创建一个新的 Set 并添加值 v
        fwd.set(k, new Set([v]));
      }
    },

    /**
     * toObject 方法：将内部的双向映射结构转换为原始的普通 JavaScript 对象格式。
     * @returns {object} 转换后的普通对象。
     */
    toObject() {
      // 将 fwd Map 转换为一个数组，其中每个元素是 [键, Set<值>]
      // 然后将 Set<值> 转换为 Array<值>
      // 最后使用 Object.fromEntries 转换为普通对象
      return Object.fromEntries(
        Array.from(fwd.entries(), ([key, valueSet]) => [
          key,
          Array.from(valueSet),
        ])
      );
    },
  };
}

const db = Db();

// 初始操作：
// db.set("fruit", "apple");
// fwd: Map { "fruit" => Set { "apple" } }
// rev: Map { "apple" => "fruit" }

// db.set("veggie", "carrot");
// fwd: Map { "fruit" => Set { "apple" }, "veggie" => Set { "carrot" } }
// rev: Map { "apple" => "fruit", "carrot" => "veggie" }

// 移动操作：将 "apple" 从 "fruit" 移动到 "dessert"
db.set("fruit", "apple");
db.set("veggie", "carrot");
db.set("dessert", "apple"); // 此时 "apple" 会从 "fruit" 移动到 "dessert"

console.log(db.toObject());
/*
输出：
{
  fruit: [], // 或者如果实现了删除空Set的逻辑，则fruit键可能不存在
  veggie: ["carrot"],
  dessert: ["apple"]
}
*/

let change = { key: 23, value: 3 };

// 模拟初始的 obj 状态
let initialData = {
  22: [7, 4, 2, 3],
  23: [1, 5, 6],
};

const db = Db();

// 将初始数据加载到 Db 实例中
for (const key in initialData) {
  for (const value of initialData[key]) {
    db.set(key, value);
  }
}

console.log("原始数据结构 (通过Db转换):", db.toObject());
/*
输出：
原始数据结构 (通过Db转换): { '22': [ 7, 4, 2, 3 ], '23': [ 1, 5, 6 ] }
*/

// 执行移动操作：将 change.value (3) 移动到 change.key (23)
db.set(change.key, change.value);

console.log("移动后的数据结构:", db.toObject());
/*
输出：
移动后的数据结构: { '22': [ 7, 4, 2 ], '23': [ 1, 5, 6, 3 ] }
*/

// 验证原始问题中后续的使用场景
let vals = {
  1: 'a',
  2: 'b',
  3: 'c',
  4: 'd',
  5: 'e',
  6: 'f',
  7: 'g',
};

let currentObj = db.toObject(); // 获取当前最新的对象表示

console.log("\n遍历并映射值:");
for (let k in currentObj) {
  let list = currentObj[k];
  for (let v of list) {
    console.log(`${k}: ${vals[v]}`);
  }
}
/*
输出：
遍历并映射值:
22: g
22: d
22: b
23: a
23: e
23: f
23: c
*/