Trao đổi khóa với giá trị JSON

Tôi có một đối tượng JSON cực kỳ lớn được cấu trúc như thế này:

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

Tôi cần một hàm có thể hoán đổi các giá trị bằng các khóa trong đối tượng của mình và tôi không biết cách thực hiện. Tôi sẽ cần một đầu ra như thế này:

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

Có cách nào tôi có thể làm điều này để tạo một đối tượng mới theo cách thủ công nơi mọi thứ được hoán đổi không?
Cảm ơn

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

Ví dụ ở đây FIDDLE đừng quên bật bảng điều khiển của bạn để xem kết quả.

Các phiên bản ES6 :

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

Hoặc sử dụng Array.reduce () & Object.keys ()

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

Hoặc sử dụng Array.reduce () & Object.entries ()

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

bạn có thể sử dụng hàm lodash _. invert nó cũng có thể sử dụng 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'] }

Sử dụng ES6:

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

Lấy các khóa của đối tượng, sau đó sử dụng chức năng giảm của Mảng để đi qua từng khóa và đặt giá trị làm khóa và khóa làm giá trị.

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

Trong ES6 / ES2015 bạn có thể kết hợp sử dụng các Object.keys và giảm với mới Object.assign chức năng, một chức năng mũi tên , và một tên thuộc tính cho một giải pháp câu lệnh khá đơn giản.

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

Nếu bạn đang chuyển đổi bằng cách sử dụng toán tử lây lan đối tượng (giai đoạn 3 kể từ khi viết bài này) sẽ đơn giản hóa mọi thứ hơn một chút.

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

Cuối cùng, nếu bạn có sẵn Object.entries (giai đoạn 4 khi viết bài), bạn có thể làm sạch logic hơn (IMO).

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

Bây giờ chúng ta có Object.fromEntries:

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

hoặc là

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

Là phần bổ sung của câu trả lời @joslarson và @jPO:
Không cần ES6, bạn có thể sử dụng và Toán tử dấu phẩy :Object.keys Array.reduce

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

Một số người có thể thấy nó xấu xí, nhưng nó "hơi" nhanh hơn vì reducekhông lan truyền tất cả các thuộc tính của objmỗi vòng lặp.

Thử

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

Điều ngắn nhất mà tôi nghĩ ra bằng cách sử dụng 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);

Sử dụng Ramda :

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

const result = swapKeysWithValues(source);

Tôi tin rằng tốt hơn nên thực hiện tác vụ này bằng cách sử dụng mô-đun npm, chẳng hạn như invert-kv.

invert-kv : Đảo khóa / giá trị của một đối tượng. Ví dụ: {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'}

Với Ramda thuần túy theo phong cách thuần túy và không có điểm nhấn:

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

Hoặc, với phiên bản ES6 phức tạp hơn một chút, vẫn hoạt động thuần túy:

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

Đây là một triển khai chức năng thuần túy của phép lật keysvà valuestrong 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))

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

Điều này có thể làm cho đối tượng của bạn, {A : 1, B : 2, C : 3, D : 4}giống như mảng, vì vậy bạn có thể có

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

Đây là một tùy chọn sẽ hoán đổi các khóa với các giá trị nhưng không làm mất các bản sao, nếu đối tượng của bạn là: {a: 1, b: 2, c: 2}, nó sẽ luôn trả về một mảng trong đầu ra:

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