JavaScript:对象重命名密钥

Question

是否有一种聪明的(即优化的)方法来重命名javascript对象中的键？

一种非优化的方式是:

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

Answer 1

我相信最完整(也是最正确)的做法是:

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

此方法可确保重命名的属性与原始属性的行为相同.

此外,在我看来,将其包装成函数/方法并将其放入的可能性Object.prototype与您的问题无关.

Answer 2

您可以将函数包装在函数中并将其分配给Object原型.也许使用流畅的界面风格来进行多次重命名流程.

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

Answer 3

如果您正在改变源对象,ES6可以在一行中完成.

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

如果要创建新对象,可以使用两行.

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

Answer 4

如果有人需要重命名属性列表:

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

Answer 5

为每个键添加前缀：

const obj = {foo: 'bar'}

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

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

Answer 6

我想用这种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"}

Answer 7

重命名键但避免更改原始对象参数

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

最好有一个新数组

Answer 8

另一种使用最强大的REDUCE方法的方法。

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

Answer 9

如果您不想变异数据，请考虑使用此功能...

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

Yazeed Bzadough的详尽解释 https://medium.com/front-end-hacking/immutably-rename-object-keys-in-javascript-5f6353c7b6dd

Answer 10

使用对象解构和散布运算符的变体：

    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 shorthand properties **kA, kB, kC**; 
// spread the remaining properties in the **rest** variable
const newObj = {kA, kB, kC, ...rest};

Answer 11

您可以尝试lodash _.mapKeys。

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>

Answer 12

只需在您最喜欢的编辑器中尝试一下 <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
}

Answer 13

重命名对象键的另一种方法：

让我们考虑一下这个对象：

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

让我们将 name 键重命名为first_name：

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

现在对象是：

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

Answer 14

我会说，从概念的角度来看，最好将旧对象（来自 Web 服务的对象）保持原样，并将您需要的值放入新对象中。我假设您在某一点或另一点提取特定字段，如果不是在客户端上，那么至少在服务器上。您选择使用与来自 Web 服务的字段名称相同的字段名称（仅小写）这一事实并没有真正改变这一点。所以，我建议做这样的事情：

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

当然，我在这里做了各种各样的假设，这可能不是真的。如果这不适用于您，或者它太慢（是吗？我没有测试过，但我想随着字段数量的增加差异会变小），请忽略所有这些:)

如果你不想这样做，而你只需要支持特定的浏览器，你也可以使用新的 getter 来返回“uppercase(field)”：见http://robertnyman.com/2009/05/28 /getters-and-setters-with-javascript-code-samples-and-demos/以及该页面上的链接以获取更多信息。

编辑：

令人难以置信的是，这几乎快了两倍，至少在我工作的 FF3.5 上是这样。见：http : //jsperf.com/spiny001

Answer 15

我会做这样的事情：

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

Answer 16

就个人而言，在不实现额外繁重的插件和轮子的情况下重命名对象中键的最有效方法：

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

object = JSON.parse(str);

try-catch如果您的对象具有无效结构，您也可以将其包装起来。完美运行:)

Answer 17

虽然这并不能完全为重命名键提供更好的解决方案，但它提供了一种快速、简单的 ES6 方法来重命名对象中的所有键，同时不改变它们包含的数据。

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

Answer 18

这里的大多数答案都无法维持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] }
  }
});

该解决方案通过将新条目添加到旧条目的位置来保留条目的顺序。

Answer 19

如果您想保留迭代顺序（插入顺序），这里有一个建议：

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
}