高效管理与移动对象中数组的值

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

{
  22: [7, 4, 2], // 3 被移除
  23: [1, 5, 6, 3], // 3 被添加
}

let change = { key: 23, value: 3 };
obj[change.key].push(change.value);
// 结果：{ 22: [7, 4, 2, 3], 23: [1, 5, 6, 3] }
// 但这并未移除原位置的值

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

// 步骤1：找到值3所在的原键
let fromKey = Object.keys(obj).find(key => obj[key].includes(change.value));

// 步骤2：从原键对应的数组中移除值3
if (fromKey) {
  obj[fromKey] = obj[fromKey].filter(item => item !== change.value);
}

// 步骤3：将值3添加到目标键对应的数组中
if (!obj[change.key]) {
    obj[change.key] = []; // 如果目标键不存在，初始化为空数组
}
obj[change.key].push(change.value);

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

/**
 * 构造一个支持高效值移动的数据库结构。
 * 内部维护正向映射 (键 -> 值集合) 和反向映射 (值 -> 键)。
 */
function Db() {
  // 正向映射：键 -> 值集合 (使用 Set 确保值唯一且高效增删)
  const fwd = new Map();
  // 反向映射：值 -> 键 (记录每个值当前所属的键)
  const rev = new Map();

  return {
    /**
     * 将一个值 (v) 移动或关联到指定的键 (k)。
     * 如果值 v 已经存在于某个键下，它将从原键中移除并关联到新键 k。
     * @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 存在，以防异常情况
        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]));
      }
    },

    /**
     * 将内部的 Db 结构转换为标准的 JavaScript 对象格式。
     * @returns {Object} 转换后的对象，键对应数组。
     */
    toObject() {
      return Object.fromEntries(
        // 遍历 fwd Map 的所有条目 (键-值Set 对)
        Array.from(
          fwd.entries(),
          // 对于每个条目，将 Set 转换为数组
          ([k, vSet]) => [k, Array.from(vSet)]
        )
      );
    },

    /**
     * (可选) 内部结构查看器，用于调试。
     */
    _debug() {
        console.log("fwd Map:", fwd);
        console.log("rev Map:", rev);
    }
  };
}

// 实例化 Db
const db = Db();

// 初始数据填充
// 假设我们从 { 22: [7, 4, 2, 3], 23: [1, 5, 6] } 开始
// 我们需要逐个设置这些初始值
db.set(22, 7);
db.set(22, 4);
db.set(22, 2);
db.set(22, 3); // 值 3 初始在键 22 下

db.set(23, 1);
db.set(23, 5);
db.set(23, 6);

console.log("初始状态:", db.toObject());
// 初始状态: { '22': [ 7, 4, 2, 3 ], '23': [ 1, 5, 6 ] }

// 执行移动操作：将值 3 移动到键 23
let change = { key: 23, value: 3 };
db.set(change.key, change.value); // 这一步会自动处理移除旧位置的值

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

// 进一步测试：移动值 7 到键 23
db.set(23, 7);
console.log("再次移动后的状态:", db.toObject());
/* 预期输出：
再次移动后的状态: { '22': [ 4, 2 ], '23': [ 1, 5, 6, 3, 7 ] }
*/

// 内部结构示例 (通过 _debug 方法查看)
// db._debug();
/* 可能的内部结构：
fwd Map: Map(2) {
  22 => Set(2) { 4, 2 },
  23 => Set(5) { 1, 5, 6, 3, 7 }
}
rev Map: Map(7) {
  7 => 23,
  4 => 22,
  2 => 22,
  3 => 23,
  1 => 23,
  5 => 23,
  6 => 23
}
*/