개체의 값을 사용하여 키

개체의 값을 사용하여 키

다음과 같이 구성된 매우 큰 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;
  }, {});
}

이제 Object.fromEntries가 있습니다.

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

console.log(
  f({A : 'a', B : 'b', C : 'c'})
) // => {a : 'A', b : 'B', c : 'C'}

또는:

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

console.log(
  f({A : 'a', B : 'b', C : 'c'})
) // => {a : 'A', b : 'B', c : 'C'}

( 불필요한 괄호를 제거하도록 업데이트됨 - thanks @devin-g-rode)

당신은 lodash 함수 _.multivalue를 사용할 수도 있습니다.

 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를 함께 사용할 수 있습니다.키를 누르고 새 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(Object.entries)를 사용할 수 있는 경우(쓰기 기준 4단계), 로직을 좀 더 정리할 수 있습니다(IMO).

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

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), {})
);

설명:

(acc[value] = key, acc)

쉼표 연산자(,) 구문 사용.

The comma operator (,)왼쪽에서 오른쪽으로 각 피연산자를 평가하고 마지막 피연산자의 값을 반환합니다.

@joslarson 및 @jPO의 답변을 종합하면 다음과 같습니다.
ES6 없이 및 쉼표 연산자를 사용할 수 있습니다.

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

어떤 사람들은 그것을 못생겼다고 생각할 수 있지만, 그것은 "킨다"가 더 빠릅니다.reduce모든 속성을 퍼뜨리지는 않습니다.obj각 루프에

Ramda 사용:

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

const result = swapKeysWithValues(source);

해라

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

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

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

console.log(swap(obj));

최신 JS 솔루션:

const swapKeyValue = (object) =>
  Object.entries(object).reduce((swapped, [key, value]) => (
    { ...swapped, [value]: key }
  ), {});

유형 스크립트:

type ValidKey = number | string;

const swapKeyValue = <K extends ValidKey, V extends ValidKey>(
  object: Record<K, V>
): Record<V, K> =>
  Object.entries(object)
    .reduce((swapped, [key, value]) => (
      { ...swapped, [value as ValidKey]: key }
    ), {} as Record<V, K>);

순수하고 포인트 없는 스타일의 순수 람다와 함께:

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}), {})

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

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

다음은 플립의 순수한 기능적 구현입니다.keys그리고.valuesES6:

타입스크립트

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

자바스크립트

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

이것은 당신의 목적을 만들 수 있습니다.{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"]}

단순한 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"] }

@Vaidd4의 응답을 다시 쓰는 중이지만 (콤마 연산자 대신) 사용:

/**
 * 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})), {});

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

제가 사용하는 솔루션은 다음과 같습니다.

function objSwap(obj, tl = false) {
    return Object.entries(obj).reduce((a, [k, v]) => (a[v = tl ? v.toLowerCase() : v] = k = tl ? k.toLowerCase() : k, a), {});
}

보너스로: 스왑이 필요하다면 일부 값을 확인하십시오. 소문자 키와 값에 가능성을 추가했습니다.간히설야합니다해정단합다니▁simply▁set▁you를 설정하면 됩니다.tl = true만약 필요하지 않다면...

function objSwap(obj) {
    return Object.entries(obj).reduce((a, [k, v]) => (a[v] = k, a), {});
}

사용for...of슬롯:슬라이드:

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

for (let [key, value] of Object.entries(obj)){
    
    obj[value] = key

    delete obj[key]

}

console.log(obj) // {1: 'A', 2: 'B', 3: 'C', 4: 'D'}

ES6 방법 중 하나는 다음과 같습니다.

const invertObject = (object) =>Object.entries(object).reduce((result, value) =>  ({...result, [value[1]]: value[0] }), {});

let obj = invertObject({A : 1, B : 2, C : 3, D : 4}); 

이전에 제안되지 않았던 TypeScript를 사용하는 안전한 방법이 있습니다.이 솔루션에는 반환 유형이 예상대로 입력된다는 것을 의미하는 두 가지 제네릭이 필요합니다.로 방법을 수행하는 것보다 빠릅니다..reduce또는Object.entries.

// Easier way to type `symbol | number | string` (the only valid keys of an object)
export type AnyKey = keyof any;

export function mirror<K extends AnyKey, V extends AnyKey>(
    object: Record<K, V>,
) {
    const ret: Partial<Record<V, K>> = {};

    for (const key in object) {
        ret[object[key]] = key;
    }

    return ret as Record<V, K>;
}

용도:

const obj = mirror({
  a: 'b',
  c: 'd',
});

// {b: 'a', d: 'c'}
obj;

저는 이 을 나는이작을업 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'}

언급URL : https://stackoverflow.com/questions/23013573/swap-key-with-value-in-object