JavaScript中高效移动对象数组值：构建双向映射数据结构

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 }; // 目标键和要移动的值

// 传统方法：查找并移除
let fromKey = Object.keys(obj).find(key => obj[key].includes(change.value));
if (fromKey) {
  obj[fromKey] = obj[fromKey].filter(item => item !== change.value);
}

// 添加到新位置
obj[change.key].push(change.value);

console.log(obj);

function Db() {
  const fwd = new Map(); // 正向映射：键 -> 值集合 (Map<string, Set<number>>)
  const rev = new Map(); // 反向映射：值 -> 键 (Map<number, string>)

  return {
    /**
     * 将一个值从其当前所属的键移动（或设置）到新的键。
     * @param {string} k - 目标键。
     * @param {number} v - 要移动的值。
     */
    set(k, v) {
      // 步骤1：如果值v已存在于某个键下，先将其从旧位置移除
      // 这一步利用了反向映射rev，实现了O(1)查找旧键
      if (rev.has(v)) {
        const oldKey = rev.get(v); // 获取值v当前的键
        // 从旧键对应的Set中删除值v
        // 这里不需要检查fwd.has(oldKey)，因为如果rev.has(v)为真，
        // 则oldKey必然在fwd中且其Set包含v（除非数据不一致）
        fwd.get(oldKey).delete(v);
      }

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

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

    /**
     * 将内部的Map结构转换回原始的JavaScript对象格式。
     * @returns {Object.<string, number[]>} 转换后的对象。
     */
    toObject() {
      // Object.fromEntries 接受一个 [key, value] 对的迭代器
      // Array.from(fwd.entries()) 将Map的迭代器转换为数组，每个元素是 [key, Set<value>]
      // 再次映射，将Set<value>转换为 Array<value>
      return Object.fromEntries(
        Array.from(
          fwd.entries(),
          ([k, vSet]) => [k, Array.from(vSet)] // 将Set转换为数组
        )
      );
    }
  };
}

// 初始数据
let initialObj = {
  22: [7, 4, 2, 3],
  23: [1, 5, 6],
};

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

// 初始填充 Db 数据结构
// 遍历原始对象，将每个值及其所属键添加到 Db 中
for (const key in initialObj) {
  initialObj[key].forEach(value => db.set(key, value));
}

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

// 执行值移动操作
let change = { key: 23, value: 3 }; // 将值3移动到键23
console.log(`\n--- 移动值 ${change.value} 到键 ${change.key} ---`);
db.set(change.key, change.value); // 调用set方法完成移动

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

// 再次移动，例如将值7移动到键23
let anotherChange = { key: 23, value: 7 };
console.log(`\n--- 再次移动值 ${anotherChange.value} 到键 ${anotherChange.key} ---`);
db.set(anotherChange.key, anotherChange.value);

console.log("\n--- 再次移动后状态 ---");
console.log(db.toObject());
/*
输出:
{
  '22': [4, 2, 3], // 注意：3已经移动到23了，所以这里是[4, 2] 如果是上面一步的输出
  // 实际上是 '22': [4, 2], '23': [1, 5, 6, 3, 7]
}
*/

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