Skip to content
对象反转
概述
对象反转是将源对象的键值对互换，构造一个新对象。由于 JavaScript 对象的键只能是字符串或 Symbol，而反转操作将原值作为新键使用，因此值会被隐式转换为字符串。这种转换是大多数意外行为的根源。
基本概念
给定一个对象 { a: 1, b: 2 }，反转后的结果为 { '1': 'a', '2': 'b' }。每个值变成了键，对应的键成为了值。当多个键映射到同一个值时，就出现了键冲突——新对象无法同时容纳两个相同的键。
一种常见的策略是将冲突的值收集到数组中，确保数据不丢失：{ a: 'x', b: 'x' } 反转为 { x: ['a', 'b'] }。
工作原理
反转过程的核心在于遍历源对象的可枚举属性，以值为新键、键为新值填入结果对象。键冲突的处理分支如下：
- 值作为键不存在 → 直接赋值。
- 值作为键已存在：
- 若已有值不是数组 → 将已有值和当前键组合成数组。
- 若已有值是数组 → 将当前键追加到该数组末尾。
这种处理方式保证了第一次冲突产生数组，后续冲突仅通过 push 追加，避免创建新数组时丢失之前累积的键。
基本用法
javascript
function invertObject(obj) {
const result = {};
for (const [key, value] of Object.entries(obj)) {
if (value in result) {
if (Array.isArray(result[value])) {
result[value].push(key);
} else {
result[value] = [result[value], key];
}
} else {
result[value] = key;
}
}
return result;
}Object.entries() 返回由 [key, value] 对组成的数组，遍历时可直接解构出键和值。value in result 使用 in 操作符检查当前值（转换为字符串后）是否已作为结果对象的键存在。若存在，根据已有值的类型决定数组化或追加。
示例
无冲突反转
javascript
invertObject({ a: 1, b: 2 });
// { '1': 'a', '2': 'b' }键与值一一对应，结果对象的每个值仍然是单一的字符串。
两个键冲突
javascript
invertObject({ a: 'x', b: 'x' });
// { x: ['a', 'b'] }值 'x' 对应两个键，结果中 x 属性的值为数组，包含所有原始键。
三个键冲突
javascript
invertObject({ a: 1, b: 1, c: 1 });
// { '1': ['a', 'b', 'c'] }连续冲突时，第二个键触发数组创建，第三个键被 push 到数组中。
数字键与字符串键的冲突
javascript
invertObject({ a: 1, b: '1' });
// { '1': ['a', 'b'] }数字 1 和字符串 '1' 在作为对象键时都会被转换为字符串 '1'，因此产生冲突。
值为对象时的表现
javascript
invertObject({ a: { name: 'Alice' }, b: { name: 'Bob' } });
// { '[object Object]': ['a', 'b'] }所有对象被转换为字符串 '[object Object]'，导致多个不同的对象值被视为同一个键，产生冲突。这源于对象值在作为属性键时的 toString 行为。
辅助语言中的对比
在 Python 中，字典的键可以是任意不可变类型，反转时值保留原始类型，不会发生隐式字符串化：
python
def invert_dict(d):
result = {}
for k, v in d.items():
if v in result:
if isinstance(result[v], list):
result[v].append(k)
else:
result[v] = [result[v], k]
else:
result[v] = k
return result
invert_dict({'a': 1, 'b': 1})
# {1: ['a', 'b']}输出字典的键是数字 1，而非字符串 '1'。若存在键 1 和 '1' 则会被视为不同的键，不会冲突，与 JavaScript 对象的字符串化行为不同。
Java 中 Map 的键是对象，同样不会强制转为字符串，反转思路类似，但需要关注泛型类型的转换。
注意点
- 隐式字符串转换：
value in result检查的是值转换为字符串后是否作为键存在。数字1、字符串"1"以及[1]（转为"1"）都可能被视为相同键。对象、数组、函数等复杂类型在用作属性键时会调用toString，得到的通常是"[object Object]"或类似字符串，极易造成意外冲突。 - 数组判断的位置：在
push之前通过Array.isArray判断已有值是否为数组，是保证数据完整的关键。如果每次冲突都使用[result[value], key]创建新数组，会把之前累积的数组降级为只有一个前值的数组，丢失历史键。 - 输入对象保持不变：反转操作返回新对象，不修改源对象，与
Object.entries配合for...of时的不可变性一致。
限制
- 仅适用于值可安全转换为字符串的场景。如果源对象的值包含对象、
undefined等，转换后的字符串化结果要么无意义，要么丢失信息。例如undefined转为字符串"undefined"，多个undefined值会冲突。 - 冲突时改用数组存储多个键，会破坏值类型的同构性：结果对象的值可能是字符串或数组，后续读取时需要额外判断类型。
Object.entries()不会枚举 Symbol 键，因此以 Symbol 为键的属性不会出现在反转结果中。此外，当 Symbol 作为值参与反转时，它会被转换为字符串（如"Symbol(description)"），之后可以通过in操作符检测，但与原始 Symbol 值不再等价，反转结果中无法通过原始 Symbol 找回对应键。
应用
对象反转常用于构建反向查找表。例如，错误码枚举：
javascript
const ERROR_CODES = { NOT_FOUND: 404, UNAUTHORIZED: 401 };
const CODE_TO_NAME = invertObject(ERROR_CODES);
// { '401': 'UNAUTHORIZED', '404': 'NOT_FOUND' }
CODE_TO_NAME[404]; // 'NOT_FOUND'如果某个值对应多个键（如多个错误名称共享同一代码），反转结果中的该代码键会对应数组，调用方需要处理这种多对一情况。
另一种常见场景是把配置项中的“别名 → 规范名”映射反转，实现从规范名查找所有别名的功能。