Переименовать ключи в объекте

Ответ 1

может быть что-то вроде этого?

var i, len = addObjectResponse.length;
for (i = 0; i < len; i++) {
    addObjectResponse[i]['O2'] = addObjectResponse[i]['SPO2'];
    delete addObjectResponse[i]['SPO2'];
}

или

addObjectResponse = addObjectResponse.map(function (obj) {
    obj['O2'] = obj['SP02'];
    delete obj['S02'];
    return obj;
});

или

for (let obj of addObjectResponse) {
    obj['O2'] = obj['SP02'];
    delete obj['S02'];
}

или

function renameProperty(obj, fromKey, toKey) {
    obj[toKey] = obj[fromKey];
    delete obj[fromKey];
}

addObjectResponse.forEach(obj => renameProperty(obj, 'SP02', 'O2'));

Ответ 2

Вы не можете напрямую переименовать свойства. Однако вы можете установить новые свойства и отключить старые, косвенно "переименовать" их:

function rename(obj, oldName, newName) {
    if(!obj.hasOwnProperty(oldName)) {
        return false;
    }

    obj[newName] = obj[oldName];
    delete obj[oldName];
    return true;
}

Ответ 3

Переименование неизменяемого ключа в однолинейном валике JS

Это может быть не самый эффективный способ переименования ключа, но я думаю, что это интересно определенным образом:

• Он не мутирует исходные объекты
• Требуется одна строка ванильного JavaScript
• Он демонстрирует использование современного синтаксиса

No.1 иногда может понадобиться, если вам все еще нужно использовать исходный массив. No.2 может быть интересным, учитывая тот факт, что некоторые из примеров здесь содержат более 30 строк кода. No.3 может служить образовательной цели, чтобы продемонстрировать некоторые из особенностей языка, которые не используются так часто, как они должны, учитывая тот факт, насколько мощными и насколько широко они поддерживаются.

Если вы создаете объект сопоставления следующим образом:

const m = { SPO2: 'O2' };

тогда вы сможете добавить больше ключей для переименования в будущем.

Теперь можно создать однострочный в ваниле JS:

const t = o => Object.assign(...Object.keys(o).map(k => ({ [m[k] || k]: o[k] })));

Скажем, что у вас есть массив объектов:

const a = [{
  'SPO2': '222.00000',
  'VitalGroupID': 1152,
}, {
  'SPO2': '333.00000',
  'VitalGroupID': 1153,
}, {
  'SPO2': '444.00000',
  'VitalGroupID': 1154,
}];

Вы можете получить новый массив с a.map(t) следующим образом:

console.log('Before:', a);
console.log('After:', a.map(t));

В исходном массиве исходные объекты все еще остаются нетронутыми.

Ответ 4

 addObjectResponse[0]["O2"] = addObjectResponse[0]["SPO2"];
 addObjectResponse[0]["SP02"] = null;

Требуется [0], потому что addObjectResponse установлен в массив с одним элементом, который содержит объект. У вас есть какие-либо правила относительно того, какие ключи будут переименованы или как?

Изменить: я неправильно понял OP, считая, что "многие объекты" ссылаются на многие ключи в объекте, которые нужно переименовать, в отличие от многих объектов в массиве, каждый из которых должен иметь переименованный один ключ.

Ответ 5

Вы можете добавить + delete (прочитайте IE caveat);

var addObjectResponse = [{
    'SPO2': '222.00000',
    'VitalGroupID': 1152
}]

for (var k in addObjectResponse[0])
    log(k)

>>SPO2
>>VitalGroupID

addObjectResponse[0]['O2'] = addObjectResponse[0]['SPO2']
delete addObjectResponse[0]['SPO2']

for (var k in addObjectResponse[0])
    log(k)

>>VitalGroupID
>>O2

Ответ 6

Вместо того, чтобы переименовывать этот ключ объекта, вы можете создать другой объект с собственными именами, например:

var obj={wrongKeyName:'test'};
var obj2 = {}
obj2.rightKeyName = obj.wrongKeyName;
console.log(obj2);

Ответ 7

Я создал хорошую функцию для переименования имен свойств: https://github.com/meni181818/simpleCloneJS/blob/master/renameProperties.js

использование:

var renamedObj = renameProperties(sourceObject, {propName: 'propNEWname', anotherPropName: 'anotherPropNEWname'});

Моя функция также обрабатывает объекты внутри массивов, поэтому в вашем случае вы можете:

addObjectResponse = renameProperties(addObjectResponse, {SPO2: 'O2'});

DEMO

function renameProperties(sourceObj, replaceList, destObj) {
    destObj = destObj || {};
    each(sourceObj, function(key) {
        if(sourceObj.hasOwnProperty(key)) {
            if(sourceObj[key] instanceof Array) {
                if(replaceList[key]) {
                    var newName = replaceList[key];
                    destObj[newName] = [];
                    renameProperties(sourceObj[key], replaceList, destObj[newName]);
                } else if(!replaceList[key]) {
                    destObj[key] = [];
                    renameProperties(sourceObj[key], replaceList, destObj[key]);
                }
            } else if(typeof sourceObj[key] === 'object') {
                if(replaceList[key]) {
                    var newName = replaceList[key];
                    destObj[newName] = {};
                    renameProperties(sourceObj[key], replaceList, destObj[newName]);
                } else if(!replaceList[key]) {
                    destObj[key] = {};
                    renameProperties(sourceObj[key], replaceList, destObj[key]);
                }             
            } else {
                if(replaceList[key]) {
                    var newName = replaceList[key];
                    destObj[newName] = sourceObj[key];
                } else if(!replaceList[key]) {
                    destObj[key] = sourceObj[key];
                }
            }
        }
    });

    return destObj;
}

в строке 3 в приведенной выше функции, мы используем функцию each(). это:

function each(objOrArr, callBack) {
    if(objOrArr instanceof Array) {
        for(var i = 0; i < objOrArr.length; i++) {
            callBack(i);
        }
    } else if(typeof objOrArr === 'object') {
        for(var prop in objOrArr) {
            // if the property really exist
            if(objOrArr.hasOwnProperty(prop)) {
                callBack(prop);
            }
        }
    }
}

note: Если вы используете Jquery OR underscore.js Или другую библиотеку, которая имеет функцию "each()", вы можете использовать ее вместо этого. просто вернитесь к $.each (jquery) или _.each (underscore.js).

Ответ 8

Итак, вот две вещи, которые вы здесь делаете, итерации через массив и переименование свойств объекта.

Во-первых, для повторения вы обычно должны использовать массивы map() function. Я думаю, что он менее подвержен ошибкам, чем использование цикла for ( .. ) и немного приятнее, чем forEach(). Цикл for ( .. ) обычно дает вам лучшую производительность (в зависимости от JS-движка), но вам нужно иметь дело с довольно массивным массивом, чтобы заметить (т.е. Может быть разница в 10 мс для 100 тыс. Элементов).

Во-вторых, чтобы переименовать свойство объекта, очевидным решением является просто установить новый ключ и удалить старый. Это будет работать, но не всегда даст вам свойства, которые ведут себя точно так же, как старый, если пользовательский геттер или сеттер был определен. Если вы создаете общую вспомогательную функцию для выполнения такой работы, вам лучше использовать Object.defineProperty() и Object.getOwnPropertyDescriptor().

Полагая это вместе, получаем:

function renameKeyInObjArray (array, oldKey, newKey) {
    return array.map(function (obj) {
        Object.defineProperty(obj, newKey, Object.getOwnPropertyDescriptor(obj, oldKey));
        delete obj[oldKey];
        return obj;
    });
}

// Use our new function to process the array
renameKeyInObjArray(addObjectResponse, 'SPO2', 'O2');

Эта функция обновляет содержимое массива по ссылке, а также возвращает ссылку на массив, поэтому его можно скопировать. Он также написан в синтаксисе ES5.1, поэтому он должен работать почти везде.