JavaScript: Objekt Umbenennen Taste

Question

Gibt es eine clevere (d.h. optimierte) Möglichkeit, einen Schlüssel in einem Javascript-Objekt umzubenennen?

Ein nicht optimierter Weg wäre:

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

Answer 1

Mein Weg, die Anpassung der gute @Mulhoon Schreibmaschinenpost zum Ändern mehrerer Tasten:

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

Answer 2

Ich würde gerne Folgendes tun

const originalObj = {
  a: 1,
  b: 2,
  c: 3, // need replace this 'c' key into 'd'
};

const { c, ...rest } = originalObj;

const newObj = { ...rest, d: c };

console.log({ originalObj, newObj });

Answer 3

Versuchen Sie es mit lodash transform.

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

Answer 4

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

Answer 5

Wäre es ein Problem, dies einfach zu tun?

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

---

Diese kann, falls gewünscht, in eine Funktion verpackt werden:

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