JavaScript: Переименовать объект

Есть ли умный (то есть оптимизированный) способ переименования ключа в javascript-объекте?

Не оптимизированный способ:

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

Ответ 1

Самый полный (и правильный) способ сделать это будет, я считаю:

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

Этот метод гарантирует, что переименованное свойство ведет себя идентично в исходное.

Кроме того, мне кажется, что возможность обернуть это в функцию/метод и поместить его в Object.prototype не имеет отношения к вашему вопросу.

Ответ 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;
        }
    }
);

Ответ 3

Если вы изменяете исходный объект, ES6 может сделать это в одну строку.

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

Или две строки, если вы хотите создать новый объект.

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

Ответ 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"}

Ответ 5

Я хотел бы просто использовать `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"}

Ответ 6

Если вы не хотите изменять свои данные, рассмотрите эту функцию...

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

Подробное объяснение Язида Бзадоу https://medium.com/front-end-hacking/immubly-rename-object-keys-in-javascript-5f6353c7b6dd

Ответ 7

Вариант с использованием объекта деструктуризации и оператора распространения:

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

Ответ 8

Вы можете попробовать 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>

Ответ 9

Я бы сделал что-то вроде этого:

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

Ответ 10

Большинство ответов здесь не поддерживают порядок пар ключ-значение JS Object. Например, если на экране имеется форма пар ключ-значение объекта, которую вы хотите изменить, важно сохранить порядок записей объектов.

Способ 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] }
  }
});

Решение сохраняет порядок записей, добавляя новую запись вместо старой.

Ответ 11

Я бы сказал, что было бы лучше с концептуальной точки зрения просто оставить старый объект (тот из веб-службы), какой он есть, и поместить нужные значения в новый объект. Я предполагаю, что вы извлекаете определенные поля в какой-то момент или в любом случае, если не на клиенте, то, по крайней мере, на сервере. Тот факт, что вы выбрали имена полей, которые являются теми же, что и в веб-службе, только в нижнем регистре, на самом деле не изменяет это. Итак, я бы посоветовал сделать что-то вроде этого:

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

Конечно, здесь я делаю всевозможные предположения, что может быть неверным. Если это не относится к вам, или если оно слишком медленное (не так ли? Я не тестировал, но, я думаю, разница становится меньше по мере увеличения количества полей), пожалуйста, проигнорируйте все это:)

Если вы не хотите этого делать, и вам нужно только поддерживать определенные браузеры, вы также можете использовать новые геттеры, чтобы также вернуть "uppercase (field)": см. http://robertnyman.com/2009/05/28/getters-and-setters-with-javascript-code-samples-and-demos/ и ссылки на этой странице для получения дополнительной информации.

EDIT:

Невероятно, это также почти в два раза быстрее, по крайней мере, на моем FF3.5 на работе. См.: http://jsperf.com/spiny001

Ответ 12

Хотя это не дает лучшего решения для переименования ключа, оно обеспечивает быстрый и простой способ ES6 переименовать все ключи в объекте, не изменяя данные, которые они содержат.

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

Ответ 13

Некоторые из решений, перечисленных на этой странице, имеют некоторые побочные эффекты:

влияет на положение ключа в объекте, добавляя его внизу (если это важно для вас)
не будет работать в 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 может не поддерживать forEach в строгом режиме

Ответ 14

Лично, самый эффективный способ переименования ключей в объекте без внедрения особо тяжелых плагинов и колес:

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

object = JSON.parse(str);

Вы также можете обернуть его в try-catch, если ваш объект имеет недопустимую структуру. Отлично работает:)

Ответ 15

Вот пример для создания нового объекта с переименованными ключами.

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

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

Ответ 16

Это небольшая модификация, которую я сделал для функции pomber; Чтобы иметь возможность взять массив объектов вместо одного объекта, а также вы можете активировать индекс. также "Ключи" могут быть назначены массивом

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

Ответ 17

Ваш путь оптимизирован, на мой взгляд. Но у вас получатся переупорядоченные ключи. Вновь созданный ключ будет добавлен в конце. Я знаю, что вы никогда не должны полагаться на порядок ключей, но если вам нужно сохранить его, вам нужно будет пройти через все ключи и создать новый объект один за другим, заменяя соответствующий ключ во время этого процесса.

Как это:

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;