สลับคีย์ด้วยค่า JSON

ฉันมีออบเจ็กต์ JSON ขนาดใหญ่มากที่มีโครงสร้างดังนี้:

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

ฉันต้องการฟังก์ชั่นที่สามารถสลับค่าด้วยคีย์ในวัตถุของฉันและฉันไม่รู้จะทำอย่างไร ฉันต้องการผลลัพธ์เช่นนี้:

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

มีวิธีใดบ้างที่ฉันสามารถทำได้เพื่อสร้างวัตถุใหม่ด้วยตนเองที่มีการสลับทุกอย่าง
ขอบคุณ

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

หรือใช้Array.reduce () & Object.keys ()

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

หรือใช้Array.reduce () & Object.entries ()

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

คุณสามารถใช้ฟังก์ชัน lodash _.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'] }

ใช้ ES6:

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

รับคีย์ของออบเจ็กต์จากนั้นใช้ฟังก์ชันลดของอาร์เรย์เพื่อผ่านแต่ละคีย์และตั้งค่าเป็นคีย์และคีย์เป็นค่า

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

ใน ES6 / ES2015 คุณสามารถรวมการใช้Object.keysและลดด้วยฟังก์ชันObject.assignใหม่ฟังก์ชันลูกศรและชื่อคุณสมบัติที่คำนวณสำหรับโซลูชันคำสั่งเดียวที่ตรงไปตรงมา

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

หากคุณกำลังถ่ายโอนโดยใช้ตัวดำเนินการกระจายวัตถุ (ขั้นตอนที่ 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 }), {});

ตอนนี้เรามี Object.fromEntries:

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

หรือ

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

ในฐานะที่เป็นส่วนเสริมของคำตอบ @joslarson และ @jPO:
หากไม่จำเป็นต้องใช้ ES6 คุณสามารถใช้และตัวดำเนินการจุลภาค :Object.keys Array.reduce

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

บางคนอาจคิดว่ามันน่าเกลียด แต่มันก็ "ค่อนข้างเร็ว" เพราะreduceมันไม่ได้กระจายคุณสมบัติทั้งหมดของobjแต่ละลูป

ลอง

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

สั้นที่สุดที่ฉันคิดโดยใช้ 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);

ใช้Ramda :

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

const result = swapKeysWithValues(source);

ฉันเชื่อว่าการทำงานนี้โดยใช้โมดูล npm จะดีกว่าเช่นinvert-kv.

invert-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'}

ด้วย 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}), {})

นี่คือการใช้งานที่แท้จริงของการพลิกkeysและvaluesใน ES6:

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

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

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}เหมือนอาร์เรย์ดังนั้นคุณจึงสามารถมีได้

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"]

นี่คือตัวเลือกที่จะสลับคีย์ที่มีค่า แต่จะไม่สูญเสียรายการที่ซ้ำกันหากวัตถุของคุณคือ: {a: 1, b: 2, c: 2} มันจะส่งคืนอาร์เรย์ในผลลัพธ์เสมอ:

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"]}