js 怎么用invert反转对象数组的键值对

Array.prototype.map()

Object.entries()

Array.prototype.reduce()

const originalArray = [
  { id: 1, name: 'Alice', role: 'Engineer' },
  { id: 2, name: 'Bob', role: 'Designer' },
  { id: 3, name: 'Charlie', role: 'Engineer' }
];

const invertedArray = originalArray.map(obj => {
  const newObj = {};
  for (const [key, value] of Object.entries(obj)) {
    // 这里要注意：如果多个键对应同一个值，后出现的会覆盖前面。
    // 比如 'Engineer' 对应 'role'，也对应 'Charlie' 的 'name'，
    // 那么最后 'Engineer' 这个新键会指向哪个值？通常是最后遍历到的那个。
    // 如果值不是字符串或数字，比如是另一个对象或数组，它会先被转换为字符串（比如 "[object Object]"），
    // 这样就失去了原有的意义，甚至可能导致多个不同的对象都映射到同一个键。
    newObj[value] = key;
  }
  return newObj;
});

// console.log(invertedArray);
/*
可能会得到类似这样的结果（取决于遍历顺序和值类型）：
[
  { '1': 'id', 'Alice': 'name', 'Engineer': 'role' },
  { '2': 'id', 'Bob': 'name', 'Designer': 'role' },
  { '3': 'id', 'Charlie': 'name', 'Engineer': 'role' }
]
*/

// 更严谨一点，用reduce来构建新对象，逻辑上更清晰：
const invertedArrayWithReduce = originalArray.map(obj => {
  return Object.entries(obj).reduce((acc, [key, value]) => {
    // 这里的关键是：确保 value 能作为新键。
    // 如果 value 是对象或数组，直接用作键会变成 '[object Object]'，通常不是你想要的。
    // 此外，如果 value 重复，例如 'Engineer' 出现了两次，那么 'Engineer' 这个新键最终会指向哪个原始键？
    // 默认行为是最后一次赋值会覆盖前一次。
    acc[value] = key;
    return acc;
  }, {});
});

// console.log(invertedArrayWithReduce);

_.invert

_.invert(someObject)

_.invert(arrayOfObjects)

_.map

// 假设你已经引入了Lodash
// import _ from 'lodash';

const invertedArrayWithLodash = originalArray.map(obj => _.invert(obj));

// 这样看起来简洁很多，但它仍然面临我们上面提到的那些挑战：
// 1. 如果原始值有重复，_.invert默认也是“后一个覆盖前一个”的策略。
// 2. 如果原始值是非字符串或数字类型（比如对象、数组），_.invert在内部会尝试将其转换为字符串作为新键，
//    结果往往是像 '[object Object]' 这样的，这基本上就废了，你根本不知道这个 '[object Object]' 对应的是哪个原始值。

{ a: 1 }

"[object Object]"

"[object Object]"

name: 'Alice'

city: 'Alice'

Alice

name

city

const invertedArrayWithMultipleKeys = originalArray.map(obj => {
  return Object.entries(obj).reduce((acc, [key, value]) => {
    // 确保 value 是一个可以作为键的类型。
    // 如果 value 已经存在，就把当前 key 添加到数组里；否则，创建一个新数组。
    if (!acc[value]) {
      acc[value] = [];
    }
    acc[value].push(key);
    return acc;
  }, {});
});

// console.log(invertedArrayWithMultipleKeys);
/*
比如对于 { id: 1, name: 'Alice', role: 'Engineer' }
和 { id: 3, name: 'Charlie', role: 'Engineer' }
你可能会得到：
{ '1': ['id'], 'Alice': ['name'], 'Engineer': ['role'] }
{ '3': ['id'], 'Charlie': ['name'], 'Engineer': ['role'] }
注意：'Engineer' 仍然是每个对象内部独立处理的。
如果你想全局地，把所有对象中相同的 'Engineer' 值对应的键都收集起来，那需要更复杂的逻辑，
比如先扁平化整个数组，再进行反转和聚合。
*/

status: 'active'

state: 'active'

'active'

123

'123'

null

undefined

true

false

Symbol

'null'

'undefined'

'true'

'Symbol(description)'

map

reduce

user.name

user.email

invertedUser['Alice']

'name'