Question

我有一个非常大的JSON对象，结构如下：

{A : 1, B : 2, C : 3, D : 4}

我需要一个可以用我的对象中的键交换值的函数，我不知道该怎么做。我需要这样的输出：

{1 : A, 2 : B, 3 : C, 4 : D}

有没有办法我可以这样做手动创建一个新对象，其中所有东西都被交换了？感谢

Answer 1

function swap(json){
  var ret = {};
  for(var key in json){
    ret[json[key]] = key;
  }
  return ret;
}

此处示例FIDDLE不要忘记打开控制台查看结果。

ES6版本：

static objectFlip(obj) {
  const ret = {};
  Object.keys(obj).forEach((key) => {
    ret[obj[key]] = key;
  });
  return ret;
}

Answer 2

获取对象的键，然后使用Array的reduce函数遍历每个键并将值设置为键，将键设置为值。

var data = {A : 1, B : 2, C : 3, D : 4}
var newData = Object.keys(data).reduce(function(obj,key){
   obj[ data[key] ] = key;
   return obj;
},{});
console.log(newData);

Answer 3

你可以使用lodash function _.invert它也可以使用multivlaue

 var object = { 'a': 1, 'b': 2, 'c': 1 };

  _.invert(object);
  // => { '1': 'c', '2': 'b' }

  // with `multiValue`
  _.invert(object, true);
  // => { '1': ['a', 'c'], '2': ['b'] }

Answer 4

在ES6 / ES2015中，您可以将Object.keys和reduce与新的Object.assign功能，arrow function和computed property name结合使用，直截了当的单一陈述解决方案。

const foo = { a: 1, b: 2, c: 3 };
const bar = Object.keys(foo)
    .reduce((obj, key) => Object.assign({}, obj, { [foo[key]]: key }), {});

如果您正在使用object spread operator（编写本文时的第3阶段）进行转换，这将进一步简化操作。

const foo = { a: 1, b: 2, c: 3 };
const bar = Object.keys(foo)
    .reduce((obj, key) => ({ ...obj, [foo[key]]: key }), {});

最后，如果您有Object.entries可用（写作时的第4阶段），您可以更多地清理逻辑（IMO）。

const foo = { a: 1, b: 2, c: 3 };
const bar = Object.entries(foo)
    .reduce((obj, [key, value]) => ({ ...obj, [value]: key }), {});

Answer 5

使用ES6：

const obj = { a: "aaa", b: "bbb", c: "ccc", d: "ddd" };
Object.assign({}, ...Object.entries(obj).map(([a,b]) => ({ [b]: a })))

Answer 6

作为@joslarson和@jPO答案的补充：
如果不需要ES6，您可以使用Object.keys Array.reduce和Comma Operator：

Object.keys(foo).reduce((obj, key) => (obj[foo[key]] = key, obj), {});

有些人可能觉得它很难看，但它更“有点”，因为reduce没有在每个循环上传播obj的所有属性。

Answer 7

2021 年的答案

使用这样的ES6语法的简洁方式。

const obj = {A : 1, B : 2, C : 3, D : 4}

console.log(
  Object.entries(obj).reduce((acc, [key, value]) => (acc[value] = key, acc), {})
);

Answer 8

现在我们有了Object.fromEntries：

obj => Object.fromEntries(Object.entries(obj).map(a => a.reverse()))

或

obj => Object.fromEntries(Object.entries(obj).map(([k, v]) => ([v, k])))

Answer 9

尝试

let swap = (o,r={})=> Object.keys(o).map(x=>r[o[x]]=x)&&r;

let obj = {A : 1, B : 2, C : 3, D : 4};

let swap = (o,r={})=> Object.keys(o).map(x=>r[o[x]]=x)&&r;

console.log(swap(obj));

Answer 10

使用Ramda：

const swapKeysWithValues = 
  R.pipe(
    R.keys,
    R.reduce((obj, k) => R.assoc(source[k], k, obj), {})
  );

const result = swapKeysWithValues(source);

Answer 11

我想出了使用ES6的最短版本。

const original = {
 first: 1,
 second: 2,
 third: 3,
 fourth: 4,
};


const modified = Object
  .entries(original)
  .reduce((all, [key, value]) => ({ ...all, [value]: key }), {});

console.log('modified result:', modified);

Answer 12

我相信最好使用invert-kv之类的npm模块来完成此任务。

反转KV ：反转对象的键/值。示例：{foo：'bar'}→{bar：'foo'}

https://www.npmjs.com/package/invert-kv

const invertKv = require('invert-kv');

invertKv({foo: 'bar', unicorn: 'rainbow'});
//=> {bar: 'foo', rainbow: 'unicorn'}

Answer 13

使用纯正的Ramda并具有纯净无点的风格：

const swapKeysAndValues = R.pipe(
   R.toPairs,
   R.map(R.reverse),
   R.fromPairs,
);

或者，使用一些复杂的ES6版本，仍可以使用纯功能：

const swapKeysAndValues2 = obj => Object
    .entries(obj)
    .reduce((newObj, [key, value]) => ({...newObj, [value]: key}), {})

Answer 14

    var data = {A : 1, B : 2, C : 3, D : 4}
    var newData = {};
    Object.keys(data).forEach(function(key){newData[data[key]]=key});
    console.log(newData);

Answer 15

这是在ES6中翻转keys和values的纯功能实现：

TypeScript

  const flipKeyValues = (originalObj: {[key: string]: string}): {[key: string]: string} => {
    if(typeof originalObj === "object" && originalObj !== null ) {
      return Object
      .entries(originalObj)
      .reduce((
        acc: {[key: string]: string}, 
        [key, value]: [string, string],
      ) => {
        acc[value] = key
        return acc;
      }, {})
    } else {
      return {};
    }
  }

JavaScript

const flipKeyValues = (originalObj) => {
    if(typeof originalObj === "object" && originalObj !== null ) {
        return Object
        .entries(originalObj)
        .reduce((acc, [key, value]) => {
          acc[value] = key
          return acc;
        }, {})
    } else {
        return {};
    }
}

const obj = {foo: 'bar'}
console.log("ORIGINAL: ", obj)
console.log("FLIPPED: ", flipKeyValues(obj))

Answer 16

current_pos

这可以使您的对象function swapKV(obj) { const entrySet = Object.entries(obj); const reversed = entrySet.map(([k, v])=>[v, k]); const result = Object.fromEntries(reversed); return result; }类似于数组，因此您可以拥有

{A : 1, B : 2, C : 3, D : 4}

Answer 17

如果您的对象是{{a：1，b：2，c：2}，它将始终在输出中返回一个数组：

#include <stdio.h>

int main() {

    int ch, len = -1;

    printf("Enter your message:");

    do {        
        ch = getchar();
        len++;
    } while (ch != '\n' && ch != EOF); //allways a good practice to check for EOF

    printf("Your message is %d characters long", len);
    return 0;
}

Answer 18

一个简单的TypeScript变体：

const reverseMap = (map: { [key: string]: string }) => {
    return Object.keys(map).reduce((prev, key) => {
        const value = map[key];
        return { ...prev, [value]: [...(prev.value || []), key] };
    }, {} as { [key: string]: [string] })
}

用法：

const map = { "a":"1", "b":"2", "c":"2" };
const reversedMap = reverseMap(map);
console.log(reversedMap);

打印： { "1":["a"], "2":["b", "c"] }

Answer 19

重写@ Vaidd4的答案，但使用Object.assign（而不是comma operator）：

/**
 * Swap object keys and values
 * @param {Object<*>} obj
 * @returns {Object<string>}
 */
function swapObject(obj) {
    return Object.keys(obj).reduce((r, key) => (Object.assign(r, {
        [obj[key]]: key,
    })), {});
}

或更短：

Object.keys(obj).reduce((r, key) => (Object.assign(r, {[obj[key]]: key})), {});

Answer 20

function myFunction(obj) {
  return Object.keys(obj).reduce((acc, cur) => {
    return {  ...acc, [obj[cur]]: cur };
     }, {});
}

使用值JSON交换密钥

20 个答案:

2021 年的答案

TypeScript

JavaScript