Rename the keys in an object

Question

var addObjectResponse = [{
    'SPO2': '222.00000',
    'VitalGroupID': 1152,
    'Temperature': 36.6666666666667,
    'DateTimeTaken': '/Date(1301494335000-0400)/',
    'UserID': 1,
    'Height': 182.88,
    'UserName': 'Admin',
    'BloodPressureDiastolic': 80,
    'Weight': 100909.090909091,
    'TemperatureMethod': 'Oral',
    'Resprate': 111,
    'HeartRate': 111,
    'BloodPressurePosition': 'Standing',
    'VitalSite': 'Popliteal',
    'VitalID': 1135,
    'Laterality': 'Right',
    'HeartRateRegularity': 'Regular',
    'HeadCircumference': '',
    'BloodPressureSystolic': 120,
    'CuffSize': 'XL',
}];

How to rename the keys... like SPO2 into O2... there are such many objects in the array...

Why do you want to do this? Maybe there is a better alternative. — James Montagne, Aug 04 '11 at 13:22
possible duplicate of [JavaScript: Object Rename Key](http://stackoverflow.com/questions/4647817/javascript-object-rename-key) — Ziggy, Nov 06 '13 at 12:02

Ilia Choly · Answer 1 · 2017-01-17T05:35:21.270

maybe something like this?

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

or

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

or

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

or

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

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

score 13 · Answer 2 · answered Aug 04 '11 at 13:24

You cannot directly rename the properties. However, you can set new properties and unset the old ones, indirectly "renaming" them:

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

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

rsp · Answer 3 · 2017-05-22T15:24:32.797

Immutable key renaming in vanilla JS one-liner

This may not be the most efficient way to rename a key but I think it's interesting in certain ways:

It doesn't mutate the original objects
It takes one line of vanilla JavaScript
It demonstrates the use of modern syntax

No.1 may sometimes be needed if you still need to use the original array. No.2 may be interesting considering the fact that some of the examples here have more than 30 lines of code. No.3 may serve an educational purpose to demostrate some of the features of the language that are not used as often as they should, considering the fact how powerful and how widely supported they are.

If you create a mapping object like this:

const m = { SPO2: 'O2' };

then you'll be able to add more keys to rename in the future easily.

Now, can create a one-liner in vanilla JS:

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

Let's say that you have an array of objects:

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

You can get a new array with a.map(t) like this:

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

Your original objects are still intact in the original array.

score 1 · Answer 4 · answered Aug 12 '14 at 13:51

I have created a nice function to rename properties names: https://github.com/meni181818/simpleCloneJS/blob/master/renameProperties.js

usage:

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

My function, also handles objects inside arrays so in your case you can do:

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

on line 3 in the function above, we using each() function. which is this:

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: If you are using Jquery OR underscore.js Or another library that has 'each()' function, you can use it Instead. just replece to $.each (jquery) or _.each (underscore.js).

score 1 · Answer 5 · answered Dec 12 '16 at 00:38

Ok, so there's two things you're doing here, iterating through an array and renaming properties of an object.

Firstly, to itterate you should generally be using the arrays map() function. It's less error prone than using a for ( .. ) loop and slightly nicer than forEach(), I think. A for ( .. ) loop will usually give you better performance (depending on the JS engine) but you need to be dealing with pretty massive array to notice (ie. maybe a ~10ms difference for 100k elements).

Secondly, to rename a object property, the obvious solution is to just set the new key and deleting the old. This will work but won't always give you properties that behave exactly like the old one if a custom getter or setter has been defined. If you're creating a generic helper function to do this kind of work you'd be better off using Object.defineProperty() and Object.getOwnPropertyDescriptor().

Putting this together we get:

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

This function updates the contents of the array by reference and also returns a reference to the array, so can be chained. It's also written in ES5.1 syntax so should run pretty much everywhere.

This should not have been down voted! Great answer and works great! — Mike, Feb 21 '18 at 19:13

score 1 · Answer 6 · answered Oct 04 '20 at 04:54

Here's one that works over an array of objects and takes a map of old object keys to new object keys.

I mostly copied the very nice code from here and just made it operate over arrays of objects rather than a single one.

Code

const renameKeys = (keysMap, objArr) =>
  (renamedArr = objArr.map((obj) =>
    Object.keys(obj).reduce(
      (acc, key) => ({
        ...acc,
        ...{ [keysMap[key] || key]: obj[key] },
      }),
      {}
    )
  ));

Example

renameKeys({ tWo: 'two', FreE: 'three' }, [
  { one: 1, tWo: 2, three: 3 },
  { one: 100, two: 200, FreE: 300 },
]);
[ { one: 1, two: 2, three: 3 }, { one: 100, two: 200, three: 300 } ]

score 0 · Answer 7 · answered Apr 27 '14 at 19:20

0

Instead of renaming this object key, you could create another object with proper names, like this:

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

answered Apr 27 '14 at 19:20

Pablo S G Pacheco

2,550
28
28

Deegii Altangerel · Answer 8 · 2021-06-10T17:28:38.150

A little late to the game here but how about something like this:

const newAddObjectResponse = addObjectResponse.map((obj) => {
    const {SPO2: O2, ...rest} = obj
    return {O2, ...rest}
})

If you want to replace your original array then you could do:

let addObjectResponse = [
    {
        SPO2: '222.00000',
        VitalGroupID: 1152,
        Temperature: 36.6666666666667,
        DateTimeTaken: '/Date(1301494335000-0400)/',
        UserID: 1,
        Height: 182.88,
        UserName: 'Admin',
        BloodPressureDiastolic: 80,
        Weight: 100909.090909091,
        TemperatureMethod: 'Oral',
        Resprate: 111,
        HeartRate: 111,
        BloodPressurePosition: 'Standing',
        VitalSite: 'Popliteal',
        VitalID: 1135,
        Laterality: 'Right',
        HeartRateRegularity: 'Regular',
        HeadCircumference: '',
        BloodPressureSystolic: 120,
        CuffSize: 'XL',
    },
]

addObjectResponse = addObjectResponse.map((obj) => {
    const {SPO2: O2, ...rest} = obj
    return {O2, ...rest}
})

taz · Answer 9 · 2011-08-04T13:30:00.680

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

The [0] is necessary because addObjectResponse is set to an array with one element, which contains an object. Do you have any rules as to what keys will be renamed or how?

Edit: I misunderstood the OP, thinking that "many objects" referred to many keys in the object that need to be renamed, as opposed to many objects in the array that each need to have that one key renamed.

score 0 · Answer 10 · answered Aug 04 '11 at 13:23

You can add + delete (read the 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

Rename the keys in an object

10 Answers10

Immutable key renaming in vanilla JS one-liner

Linked

Related