JavaScript中高效管理和重分类数组值：构建双向映射数据结构

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

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

// 将值添加到目标数组
// 确保目标键对应的数组存在
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() {
  const fwd = new Map(); // 正向映射: 类别键 -> Set<值>
  const rev = new Map(); // 反向映射: 值 -> 类别键

  return {
    /**
     * 将一个值关联到指定的类别键。
     * 如果该值已存在于其他类别中，则会先从原类别中移除。
     * @param {any} k - 目标类别键
     * @param {any} v - 要移动或添加的值
     */
    set(k, v) {
      // 1. 检查值 'v' 是否已经存在于某个类别中
      if (rev.has(v)) {
        const oldKey = rev.get(v); // 获取值 'v' 的旧类别键
        const oldKeyValues = fwd.get(oldKey); // 获取旧类别键对应的Set

        // 从旧类别的Set中移除值 'v'
        if (oldKeyValues) {
          oldKeyValues.delete(v);
          // 如果旧类别的Set变为空，则从fwd中删除该类别键
          if (oldKeyValues.size === 0) {
            fwd.delete(oldKey);
          }
        }
      }

      // 2. 更新反向映射: 将值 'v' 关联到新的类别键 'k'
      rev.set(v, k);

      // 3. 更新正向映射: 将值 'v' 添加到新类别键 'k' 对应的Set中
      if (fwd.has(k)) {
        fwd.get(k).add(v); // 类别 'k' 已存在，直接添加值
      } else {
        fwd.set(k, new Set([v])); // 类别 'k' 不存在，创建新的Set并添加值
      }
    },

    /**
     * 将内部数据结构转换为标准的JavaScript对象。
     * @returns {Object} 转换后的对象
     */
    toObject() {
      // 将fwd Map的条目转换为[key, array]形式的数组，再转换为对象
      return Object.fromEntries(
        Array.from(
          fwd.entries(),
          ([k, vSet]) => [k, Array.from(vSet)] // 将Set转换为Array
        )
      );
    },

    // 辅助方法：初始化Db实例，将现有普通对象数据导入
    _initializeFromPlainObject(plainObj) {
      for (const key in plainObj) {
        if (plainObj.hasOwnProperty(key) && Array.isArray(plainObj[key])) {
          for (const value of plainObj[key]) {
            this.set(key, value); // 使用set方法确保双向映射的正确建立
          }
        }
      }
    }
  };
}

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

// 1. 创建Db实例并导入初始数据
const db = Db();
db._initializeFromPlainObject(initialObj);

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

// 2. 执行值移动操作
let change = { key: 23, value: 3 }; // 将值 3 移动到类别 23

db.set(change.key, change.value); // 调用set方法，实现高效移动

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

// 3. 验证其他操作
db.set(22, 1); // 尝试将值 1 移动到类别 22
console.log("再次移动后的数据 (toObject):", db.toObject());
/*
输出:
再次移动后的数据 (toObject): { '22': [ 7, 4, 2, 1 ], '23': [ 5, 6, 3 ] }
*/

// 内部映射结构示例 (便于理解):
// 假设经过上述操作后，fwd 和 rev 可能的内部状态：
/*
fwd = Map {
  '22': Set { 7, 4, 2, 1 },
  '23': Set { 5, 6, 3 }
}

rev = Map {
  7: '22',
  4: '22',
  2: '22',
  3: '23',
  1: '22',
  5: '23',
  6: '23'
}
*/