Schlüssel mit Wert JSON tauschen

Ich habe ein extrem großes JSON-Objekt, das wie folgt aufgebaut ist:

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

Ich brauche eine Funktion, die die Werte mit Schlüsseln in meinem Objekt austauschen kann, und ich weiß nicht, wie es geht. Ich würde eine Ausgabe wie diese benötigen:

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

Gibt es eine Möglichkeit, dies zu tun, indem manuell ein neues Objekt erstellt wird, in dem alles ausgetauscht wird?
Vielen Dank

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

Beispiel hier FIDDLE Vergessen Sie nicht, Ihre Konsole einzuschalten , um die Ergebnisse zu sehen.

ES6- Versionen:

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

Oder verwenden Sie Array.reduce () & Object.keys ()

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

Oder verwenden Sie Array.reduce () & Object.entries ()

static objectFlip(obj) {
  return Object.entries(obj).reduce((ret, entry) => {
    const [ key, value ] = entry;
    ret[ value ] = key;
    return ret;
  }, {});
}

Sie können die lodash-Funktion _.invert verwenden. Sie kann auch multivlaue verwenden

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

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

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

Verwenden von ES6:

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

Holen Sie sich die Schlüssel des Objekts und verwenden Sie dann die Reduktionsfunktion des Arrays, um jeden Schlüssel durchzugehen und den Wert als Schlüssel und den Schlüssel als Wert festzulegen.

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

In ES6 / ES2015 können Sie nutzen kombinieren Object.keys und reduzieren mit der neuen Object.assign Funktion, eine Pfeil - Funktion und einem berechneten Eigenschaftsnamen für eine ziemlich einfache einzelne Anweisung Lösung.

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

Wenn Sie mit dem Objektverbreitungsoperator transpilieren (Stufe 3 zum Zeitpunkt des Schreibens), wird dies die Dinge ein wenig weiter vereinfachen.

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

Wenn Sie Object.entries zur Verfügung haben (Stufe 4 zum Zeitpunkt des Schreibens), können Sie die Logik ein wenig mehr bereinigen (IMO).

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

Jetzt, wo wir Object.fromEntries haben:

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

oder

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

Als Ergänzung zu den Antworten von @joslarson und @jPO:
Ohne ES6 können Sie und den Komma-Operator verwenden :Object.keys Array.reduce

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

Einige mögen es hässlich finden, aber es ist "irgendwie" schneller, da reducees nicht alle Eigenschaften von objauf jeder Schleife verbreitet.

Versuchen

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

Die kürzeste, die ich mir mit ES6 ausgedacht habe.

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

Verwenden von Ramda :

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

const result = swapKeysWithValues(source);

Ich glaube, es ist besser, diese Aufgabe mit einem npm-Modul zu erledigen, wie z invert-kv.

invert-kv : Invertiert den Schlüssel / Wert eines Objekts. Beispiel: {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'}

Mit reinem Ramda in einem reinen und punktfreien Stil:

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

Oder mit einer etwas komplizierteren ES6-Version immer noch rein funktional:

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

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

Hier ist eine rein funktionale Implementierung von Flipping keysund valuesin ES6:

Typoskript

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

function swapKV(obj) {
  const entrySet = Object.entries(obj);
  const reversed = entrySet.map(([k, v])=>[v, k]);
  const result = Object.fromEntries(reversed);
  return result;
}

Dies kann Ihr Objekt {A : 1, B : 2, C : 3, D : 4}Array-artig machen, so dass Sie haben können

const o = {A : 1, B : 2, C : 3, D : 4}
const arrayLike = swapKV(o);
arrayLike.length = 5;
const array = Array.from(arrayLike);
array.shift(); // undefined
array; // ["A", "B", "C", "D"]

Hier ist eine Option, die Schlüssel mit Werten austauscht, aber keine Duplikate verliert. Wenn Ihr Objekt: {a: 1, b: 2, c: 2} lautet, gibt es immer ein Array in der Ausgabe zurück:

function swapMap(map) {
    const invertedMap = {};
    for (const key in map) {
        const value = map[key];
        invertedMap[value] = invertedMap[value] || [];
        invertedMap[value].push(key);
    }
    return invertedMap;
}
swapMap({a: "1", b: "2", c: "2"})
// Returns => {"1": ["a"], "2":["b", "c"]}