Rename the keys in an object

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,
开发者_如何学Python    '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...

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

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

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:

1. It doesn't mutate the original objects
2. It takes one line of vanilla JavaScript
3. 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.

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

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.

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

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

 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.

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

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