Change object key using Object.keys ES6

Here is the full code for replacing keys based on object that maps the values to replace:

const tab = {abc: 1, def: 40, xyz: 50};
const replacements = {'abc': 'a_b_c', 'def': 'd_e_f'};

let replacedItems = Object.keys(tab).map((key) => {
  const newKey = replacements[key] || key;
  return { [newKey] : tab[key] };
});

This will output an array with three objects where keys are replaced. If you want to create a new object out of them, just:

const newTab = replacedItems.reduce((a, b) => Object.assign({}, a, b));

This outputs: {"a_b_c": 1, "d_e_f": 40, "xyz": 50}

With lodash mapKeys function its quite easy to transform object keys.

let tab = {
  abc: 1,
  def: 40,
  xyz: 50
}

const map = {
  abc: "newabc",
  def: "newdef",
  xyz: "newxyz"
}

// Change keys
_.mapKeys(tab, (value, key) => {
  return map[value];
});

// -> { newabc: 1, newdef: 40, newxyz: 50 }

Here is a way to do it with deconstructing assignment and arrow functions.

const rename = (({abc: a_b_c, ...rest}) => ({a_b_c, ...rest}))
console.log(rename({abc: 1, def: 2}))
// { "a_b_c": 1, "def": 2 }

UPDATE: Sorry for the syntax errors; corrected and verified in browser console.

Shortest way I've found so far:

let tab = {abc: 1, def: 40, xyz: 50};

const {abc: a_b_c, def: d_e_f, ...rest} = tab;
tab = {a_b_c, d_e_f, ...rest}  
// { "a_b_c": 1, "d_e_f": 40, "xyz": 50}

That's easy with lodash.

import { mapKeys } from 'lodash';    

const tab = {
    abc: 1,
    def: 40,
    xyz: 50
};

const test = mapKeys(tab, (value, key) => {
    if (key === 'abc') return 'a_b_c';
    return key;
});

A really easy way to change the keys dynamically without having to map the new key values could work like this :

const tab = { abc: 1, def: 40, xyz: 50 };
const changeString = (s) => s.split('').join('_');

Object.entries(tab).reduce((acc, [k, v]) => ({ ...acc, [changeString(k)]: v }), {})

// Output: {a_b_c: 1, d_e_f: 40, x_y_z: 50}

It uses Object.entries but you can easily swap it over to Object.keys like this:

Object.keys(tab).reduce((acc, k) => ({ ...acc, [changeString(k)]: tab[k] }), {})

Advanced: Nested objects

If you have nested objects and want to cycle through all the keys, you could try this:

const changeString = (s) => s.split('').join('_');
const isArray = (a) => Array.isArray(a);
const isObject = (o) => o === Object(o) && !isArray(o) && typeof o !== 'function';

const keyChanger = (o) => {
  if (isObject(o)) {
    return Object.entries(o).reduce((acc, [k, v]) => ({ ...acc, [changeString(k)]: keyChanger(v) }), {})

  } else if (isArray(o)) {
    return o.map((i) => keyChanger(i));
  }

  return o;
};

And you call it by simply doing this:

const tab2 = { abc: 1, def: 40, xyz: { hij: 12, klm: [{ nop: 43 }, { qrs: 65 }]}}

keyChanger(tab2)

// Output: { a_b_c: 1, d_e_f: 40, x_y_z: { h_i_j: 12, k_l_m: [{ n_o_p: 43 }, { q_r_s: 65 }]}}

You can add the new key and delete the old one.

var tab = {
abc:1,
def:40,
xyz: 50
}

    var key = 'abc'
    console.log(key)
    tab['a_b_c'] = tab[key]
    delete tab[key]
    
 
console.log(tab);

<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react-dom.min.js"></script>

you can use ES6 destructuring for it. For example, you can do something like this:

let sample = {a:1,b:2,c:3}
let {a:pippo,...rest} = sample
sample={pippo,...rest}

hope this will help

initial data:

let tab = {
    abc: 1,
    def: 40,
    xyz: 50
};

new key mappings:

let newKeyMappings = {
    abc: 'cab',
    def: 'fed',
    xyz: 'zyx'
};

mapping values with new keys

let mapped = Object.keys(tab).map(oldKey=> {
    let newKey = newKeyMappings[oldKey];
    let result ={};
    result[newKey]=tab[oldKey];
    return result;
});

since mapped contains array of mapped object apply reduce operator

let result = mapped.reduce((result, item)=> {
    let key = Object.keys(item)[0];
    result[key] = item[key];
    return result;
}, {});