JavaScript: 객체 이름 변경 키

JavaScript: 객체 이름 변경 키

Javascript 객체에서 키의 이름을 바꿀 수 있는 현명한(최적화된) 방법이 있습니까?

최적화되지 않은 방법은 다음과 같습니다.

o[ new_key ] = o[ old_key ];
delete o[ old_key ];

가장 완벽하고 올바른 방법은 다음과 같습니다.

if (old_key !== new_key) {
    Object.defineProperty(o, new_key,
        Object.getOwnPropertyDescriptor(o, old_key));
    delete o[old_key];
}

이 방법을 사용하면 이름이 변경된 속성이 원래 속성과 동일하게 동작합니다.

해서, ,, 방, 이, 방, 방, 방, 에, 에, 에, 에, 고, 고, 고, 고, 고, 고, 고, 고, 고, 고, 고, 고, 고, 고, 고, 고, 고, 고, also, also, it, it, , it, it, it, ,Object.prototype당신의 질문과 무관합니다.

소스 개체를 변환하는 경우 ES6는 한 줄로 변환할 수 있습니다.

delete Object.assign(o, {[newKey]: o[oldKey] })[oldKey];

또는 새 개체를 만들려면 두 줄을 사용하십시오.

const newObject = {};
delete Object.assign(newObject, o, {[newKey]: o[oldKey] })[oldKey];

이렇게 '일부러'에할 수 .Object프로토타입입니다.복수의 이름을 플로우 하려면 , fluent 인터페이스 스타일을 사용합니다.

Object.prototype.renameProperty = function (oldName, newName) {
     // Do nothing if the names are the same
     if (oldName === newName) {
         return this;
     }
    // Check for the old property name to avoid a ReferenceError in strict mode.
    if (this.hasOwnProperty(oldName)) {
        this[newName] = this[oldName];
        delete this[oldName];
    }
    return this;
};

ECMAScript 5 특정

구문이 이렇게 복잡하지 않았으면 좋겠지만 좀 더 컨트롤이 잘 되는 것은 확실합니다.

Object.defineProperty(
    Object.prototype, 
    'renameProperty',
    {
        writable : false, // Cannot alter this property
        enumerable : false, // Will not show up in a for-in loop.
        configurable : false, // Cannot be deleted via the delete operator
        value : function (oldName, newName) {
            // Do nothing if the names are the same
            if (oldName === newName) {
                return this;
            }
            // Check for the old property name to 
            // avoid a ReferenceError in strict mode.
            if (this.hasOwnProperty(oldName)) {
                this[newName] = this[oldName];
                delete this[oldName];
            }
            return this;
        }
    }
);

속성 목록의 이름을 변경해야 하는 경우:

function renameKeys(obj, newKeys) {
  const keyValues = Object.keys(obj).map(key => {
    const newKey = newKeys[key] || key;
    return { [newKey]: obj[key] };
  });
  return Object.assign({}, ...keyValues);
}

사용방법:

const obj = { a: "1", b: "2" };
const newKeys = { a: "A", c: "C" };
const renamedObj = renameKeys(obj, newKeys);
console.log(renamedObj);
// {A:"1", b:"2"}

냥용사 using the the the the 를 사용하고 .ES6(ES2015) 빨리!

시대에 뒤떨어지지 않으면 안 돼!

const old_obj = {
    k1: `111`,
    k2: `222`,
    k3: `333`
};
console.log(`old_obj =\n`, old_obj);
// {k1: "111", k2: "222", k3: "333"}


/**
 * @author xgqfrms
 * @description ES6 ...spread & Destructuring Assignment
 */

const {
    k1: kA, 
    k2: kB, 
    k3: kC,
} = {...old_obj}

console.log(`kA = ${kA},`, `kB = ${kB},`, `kC = ${kC}\n`);
// kA = 111, kB = 222, kC = 333

const new_obj = Object.assign(
    {},
    {
        kA,
        kB,
        kC
    }
);

console.log(`new_obj =\n`, new_obj);
// {kA: "111", kB: "222", kC: "333"}

각 키에 접두사를 추가하려면:

const obj = {foo: 'bar'}

const altObj = Object.fromEntries(
  Object.entries(obj).map(([key, value]) => 
    // Modify key here
    [`x-${key}`, value]
  )
)

// altObj = {'x-foo': 'bar'}

객체 파괴 및 확산 연산자를 사용한 변동:

const old_obj = {
    k1: `111`,
    k2: `222`,
    k3: `333`
};    

// destructuring, with renaming. The variable 'rest' will hold those values not assigned to kA, kB, or kC.
const {
    k1: kA, 
    k2: kB, 
    k3: kC,
    ...rest
} = old_obj;
    

// now create a new object, with the renamed properties kA, kB, kC; 
// spread the remaining original properties in the 'rest' variable
const newObj = {kA, kB, kC, ...rest};

하나의 키에 대해 다음과 같이 간단하게 할 수 있습니다.

const { k1: kA, ...rest } = old_obj;
const new_obj = { kA, ...rest }

또한 보다 '전통적인' 스타일을 선호할 수도 있습니다.

const { k1, ...rest } = old_obj
const new_obj = { kA: k1, ...rest}

데이터를 변환하지 않으려면 이 기능을 고려하십시오.

renameProp = (oldProp, newProp, { [oldProp]: old, ...others }) => ({
  [newProp]: old,
  ...others
})

자세한 설명: Yazed Bzadough https://medium.com/front-end-hacking/immutably-rename-object-keys-in-javascript-5f6353c7b6dd

---

다음은 타이프 스크립트에 적합한 버전입니다.

// These generics are inferred, do not pass them in.
export const renameKey = <
  OldKey extends keyof T,
  NewKey extends string,
  T extends Record<string, unknown>
>(
  oldKey: OldKey,
  newKey: NewKey extends keyof T ? never : NewKey,
  userObject: T
): Record<NewKey, T[OldKey]> & Omit<T, OldKey> => {
  const { [oldKey]: value, ...common } = userObject

  return {
    ...common,
    ...({ [newKey]: value } as Record<NewKey, T[OldKey]>)
  }
}

기존 키를 크러빙하거나 동일한 키로 이름을 변경하는 것을 방지합니다.

이 답변의 대부분은 JS 객체 키-값 쌍 순서를 유지하지 못합니다.예를 들어 화면에서 변경할 객체 키와 값 쌍의 형식이 있는 경우 객체 엔트리의 순서를 유지하는 것이 중요합니다.

ES6에서 JS 객체를 루프하여 키와 값의 쌍을 변경된 키 이름의 새 쌍으로 대체하는 방법은 다음과 같습니다.

let newWordsObject = {};

Object.keys(oldObject).forEach(key => {
  if (key === oldKey) {
    let newPair = { [newKey]: oldObject[oldKey] };
    newWordsObject = { ...newWordsObject, ...newPair }
  } else {
    newWordsObject = { ...newWordsObject, [key]: oldObject[key] }
  }
});

솔루션에서는 오래된 엔트리를 대신하여 새로운 엔트리를 추가하여 엔트리의 순서를 유지합니다.

lodash 를 사용해 보세요.

var user = {
  name: "Andrew",
  id: 25,
  reported: false
};

var renamed = _.mapKeys(user, function(value, key) {
  return key + "_" + user.id;
});

console.log(renamed);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>

개인적으로는 무거운 플러그인과 휠을 구현하지 않고 오브젝트 내에서 키의 이름을 변경하는 가장 효과적인 방법은 다음과 같습니다.

var str = JSON.stringify(object);
str = str.replace(/oldKey/g, 'newKey');
str = str.replace(/oldKey2/g, 'newKey2');

object = JSON.parse(str);

싸서 쓸 도 있어요.try-catch★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★은 완벽합니다 ★★★★★★★★★★★★★★★★★:)

키 이름을 바꾸되 원래 개체 매개 변수는 변경하지 마십시오.

oldJson=[{firstName:'s1',lastName:'v1'},
         {firstName:'s2',lastName:'v2'},
         {firstName:'s3',lastName:'v3'}]

newJson = oldJson.map(rec => {
  return {
    'Last Name': rec.lastName,
    'First Name': rec.firstName,  
     }
  })
output: [{Last Name:"v1",First Name:"s1"},
         {Last Name:"v2",First Name:"s2"},
         {Last Name:"v3",First Name:"s3"}]

새로운 어레이가 있는 것이 좋다

난 이런 걸 할 거야

function renameKeys(dict, keyMap) {
  return _.reduce(dict, function(newDict, val, oldKey) {
    var newKey = keyMap[oldKey] || oldKey
    newDict[newKey] = val 
    return newDict
  }, {})
}

가장 강력한 REDURE 방법을 사용하는 또 다른 방법입니다.

data = {key1: "value1", key2: "value2", key3: "value3"}; 

keyMap = {key1: "firstkey", key2: "secondkey", key3: "thirdkey"};

mappedData = Object.keys(keyMap).reduce((obj,k) => Object.assign(obj, { [keyMap[k]]: data[k] }),{});

console.log(mappedData);
// { "firstkey": "value1", "secondkey": "value2", "thirdkey": "value3"}

마음에 드는 에디터로 시험해 보세요.< 3 >

const obj = {1: 'a', 2: 'b', 3: 'c'}

const OLD_KEY = 1
const NEW_KEY = 10

const { [OLD_KEY]: replaceByKey, ...rest } = obj
const new_obj = {
  ...rest,
  [NEW_KEY]: replaceByKey
}

개념적인 관점에서는 오래된 오브젝트(Web Service의 오브젝트)는 그대로 두고 필요한 값을 새로운 오브젝트에 넣는 것이 좋다고 생각합니다.클라이언트가 아닌 경우 적어도 서버에서 특정 필드를 추출하고 있다고 가정합니다.웹 서비스의 필드 이름과 소문자만 동일한 필드 이름을 사용하기로 선택했다고 해서 이 내용은 변경되지 않습니다.따라서 다음과 같은 작업을 수행할 것을 권장합니다.

var myObj = {
    field1: theirObj.FIELD1, 
    field2: theirObj.FIELD2,
    (etc)
}

물론, 나는 여기서 온갖 추측을 하고 있지만, 사실이 아닐 수도 있어요.해당되지 않거나 속도가 너무 느린 경우(그렇습니까?테스트한 적은 없습니다만, 필드의 수가 증가함에 따라 차이는 작아질 것으로 생각됩니다).이 모든 것을 무시해 주세요.

이 작업을 수행하지 않고 특정 브라우저만 지원해야 하는 경우 새로운 getters를 사용하여 "field"(필드)를 반환할 수도 있습니다. 자세한 내용은 http://robertnyman.com/2009/05/28/getters-and-setters-with-javascript-code-samples-and-demos/ 및 해당 페이지 링크를 참조하십시오.

편집:

놀랍게도, 이 속도는 적어도 회사 FF3.5에서는 거의 두 배나 빠릅니다.참조: http://jsperf.com/spiny001

이렇게 하면 키 이름을 변경하는 데 더 나은 솔루션이 제공되지는 않지만, 포함된 데이터를 변환하지 않으면서 개체 내의 모든 키의 이름을 쉽고 빠르게 변경할 수 있습니다.

let b = {a: ["1"], b:["2"]};
Object.keys(b).map(id => {
  b[`root_${id}`] = [...b[id]];
  delete b[id];
});
console.log(b);

반복 순서(삽입 순서)를 유지하는 경우는, 다음과 같이 추천합니다.

const renameObjectKey = (object, oldName, newName) => {

  const updatedObject = {}

  for(let key in object) {
      if (key === oldName) {
          newObject[newName] = object[key]
      } else {
          newObject[key] = object[key]
      }
  }

  object = updatedObject
}

이 페이지에 기재되어 있는 솔루션에는 다음과 같은 부작용이 있습니다.

1. 오브젝트 내 키의 위치에 영향을 주고 키를 하단에 추가합니다(이것이 중요한 경우).
2. IE9+에서는 동작하지 않습니다(이것도 문제가 된다면)

다음은 키의 위치를 같은 위치에 유지하고 IE9+와 호환되지만 새로운 개체를 생성해야 하므로 가장 빠른 솔루션이 아닐 수 있습니다.

function renameObjectKey(oldObj, oldName, newName) {
    const newObj = {};

    Object.keys(oldObj).forEach(key => {
        const value = oldObj[key];

        if (key === oldName) {
            newObj[newName] = value;
        } else {
            newObj[key] = value;
        }
    });

    return newObj;
}

주의:IE9은 엄밀한 모드에서는 각각을 지원하지 않을 수 있습니다.

다음은 이름이 변경된 키를 사용하여 새 개체를 만드는 예입니다.

let x = { id: "checkout", name: "git checkout", description: "checkout repository" };

let renamed = Object.entries(x).reduce((u, [n, v]) => {
  u[`__${n}`] = v;
  return u;
}, {});

오브젝트 키의 이름을 변경해야 하는 경우:

 
  const renameKeyObject = (obj, oldKey, newKey) => {
      if (oldKey === newKey) return obj;
      Object.keys(obj).forEach((key) => {
          if (key === oldKey) {
              obj[newKey] = obj[key];
              delete obj[key];
            } else if (obj[key] !== null && typeof obj[key] === "object") {
                obj[key] = renameKeyObject(obj[key], oldKey, newKey);
              }
            });
  return obj;
};

이것은 포머의 기능을 약간 수정한 것입니다.개체만 사용하는 것이 아니라 오브젝트 배열을 사용할 수 있고 인덱스를 활성화할 수도 있습니다.또한 배열에 의해 "키"를 할당할 수도 있습니다.

function renameKeys(arrayObject, newKeys, index = false) {
    let newArray = [];
    arrayObject.forEach((obj,item)=>{
        const keyValues = Object.keys(obj).map((key,i) => {
            return {[newKeys[i] || key]:obj[key]}
        });
        let id = (index) ? {'ID':item} : {}; 
        newArray.push(Object.assign(id, ...keyValues));
    });
    return newArray;
}

시험

const obj = [{ a: "1", b: "2" }, { a: "5", b: "4" } ,{ a: "3", b: "0" }];
const newKeys = ["A","C"];
const renamedObj = renameKeys(obj, newKeys);
console.log(renamedObj);

내 생각에 네 방식은 최적화 되어 있어.하지만 결국 다시 정렬된 키를 갖게 될 것입니다.새로 작성한 키가 마지막에 추가됩니다.키 오더에 의존해서는 안 된다는 것을 알고 있습니다만, 이 오더를 보존할 필요가 있는 경우는, 모든 키를 조사해 새로운 오브젝트를 1개씩 작성하고, 그 사이에 문제의 키를 치환할 필요가 있습니다.

다음과 같이 합니다.

var new_o={};
for (var i in o)
{
   if (i==old_key) new_o[new_key]=o[old_key];
   else new_o[i]=o[i];
}
o=new_o;

• 유틸리티를 사용하여 이 문제를 해결할 수 있습니다.

npm i paix

import { paix } from 'paix';

const source_object = { FirstName: "Jhon", LastName: "Doe", Ignored: true };
const replacement = { FirstName: 'first_name', LastName: 'last_name' };
const modified_object = paix(source_object, replacement);

console.log(modified_object);
// { Ignored: true, first_name: 'Jhon', last_name: 'Doe' };

오브젝트 키의 이름을 변경하는 다른 방법:

다음 오브젝트에 대해 생각해 보겠습니다.

let obj = {"name": "John", "id": 1, "last_name": "Doe"}

이름 키의 이름을 first_name으로 변경합니다.

let { name: first_name, ...rest } = obj;
obj = { first_name, ...rest }

오브젝트는 다음과 같습니다.

{"first_name": "John", "id": 1, "last_name": "Doe"}

lodash 변환을 사용하려고 합니다.

var _ = require('lodash');

obj = {
  "name": "abc",
  "add": "xyz"
};

var newObject = _.transform(obj, function(result, val, key) {

  if (key === "add") {
    result["address"] = val
  } else {
    result[key] = val
  }
});
console.log(obj);
console.log(newObject);

const clone = (obj) => Object.assign({}, obj);

const renameKey = (object, key, newKey) => {

    const clonedObj = clone(object);
  
    const targetKey = clonedObj[key];
  
  
  
    delete clonedObj[key];
  
    clonedObj[newKey] = targetKey;
  
    return clonedObj;
     };

  let contact = {radiant: 11, dire: 22};





contact = renameKey(contact, 'radiant', 'aplha');

contact = renameKey(contact, 'dire', 'omega');



console.log(contact); // { aplha: 11, omega: 22 };

이렇게 하는 것만으로 문제가 없을까요?

someObject = {...someObject, [newKey]: someObject.oldKey}
delete someObject.oldKey

---

원하는 경우 함수로 묶을 수 있습니다.

const renameObjectKey = (object, oldKey, newKey) => {
    // if keys are the same, do nothing
    if (oldKey === newKey) return;
    // if old key doesn't exist, do nothing (alternatively, throw an error)
    if (!object.oldKey) return;
    // if new key already exists on object, do nothing (again - alternatively, throw an error)
    if (object.newKey !== undefined) return;

    object = { ...object, [newKey]: object[oldKey] };
    delete object[oldKey];

    return { ...object };
};

---

// in use
let myObject = {
    keyOne: 'abc',
    keyTwo: 123
};

// avoids mutating original
let renamed = renameObjectKey(myObject, 'keyTwo', 'renamedKey');

console.log(myObject, renamed);
// myObject
/* {
    "keyOne": "abc",
    "keyTwo": 123,
} */

// renamed
/* {
    "keyOne": "abc",
    "renamedKey": 123,
} */

my way, good @Mulhoon typscript post를 여러 키를 변경하는 방법:

const renameKeys = <
    TOldKey extends keyof T,
    TNewkey extends string,
    T extends Record<string, unknown>
>(
  keys:  {[ key: string]: TNewkey extends TOldKey ? never : TNewkey },
  obj: T
) => Object
    .keys(obj)
    .reduce((acc, key) => ({
        ...acc,
        ...{ [keys[key] || key]: obj[key] }
    }), {});

renameKeys({id: 'value', name: 'label'}, {id: 'toto_id', name: 'toto', age: 35});

개체의 동일한 순서를 유지하려면

changeObjectKeyName(objectToChange, oldKeyName: string, newKeyName: string){
  const otherKeys = cloneDeep(objectToChange);
  delete otherKeys[oldKeyName];

  const changedKey = objectToChange[oldKeyName];
  return  {...{[newKeyName] : changedKey} , ...otherKeys};

}

사용방법:

changeObjectKeyName ( {'a' : 1}, 'a', 'A');

언급URL : https://stackoverflow.com/questions/4647817/javascript-object-rename-key