I have implemented a recursive function that converts an object's keys according to another lookup table/map. You are able to convert back and forth using the 3rd swap_conversion_table_key_value boolean argument.My use case is to convert object keys to single characters to slim down the amount of characters generated from JSON.stringify. Then be able to convert it back to full keys on another client.Along with the usual code review criteria(mainly clarity), I am wondering if I just reinvented the wheel or overthought the whole problem. The code does seem a bit long for the functionality and I am not keen how it directly modifies the object(wish it would return a new object). This means that you have to clone the data before every use to keep all the references to the original data happy.Demo: jsFiddleUsage:recursiveConvertKeys(resultant_data, conversion_table, false);// 3rd parameter defines whether we should swap the key-value in the table/map (good for converting back to the original data)recursiveConvertKeys(resultant_data, conversion_table, true);Code:Code available as a GitHub Gistfunction recursiveConvertKeys(data_object, conversion_table, swap_conversion_table_key_value, __is_recursive_iteration, __current_object_level, __current_conversion_table_level){    // Do not pass in parameters for the double underscore arguments. These are private and only used for self recursive calling    //    // Demo: http://jsfiddle.net/MadLittleMods/g3g0g1L4/    // GitHub Gist: https://gist.github.com/MadLittleMods/7b9ec36879fd24938ad2    // Code Review: http://codereview.stackexchange.com/q/69651/40165    //    /* Usage:         var data = {asdf: 1, qwer: 2};        var conversion_table = {asdf: 'a', qwer: 'q'};        // Clone the data so we don't overwrite it        var resultant_data = $.extend(true, {}, data);        // Now execute the key converting process        recursiveConvertKeys(resultant_data, conversion_table, false);        console.log(Reversed Data:, resultant_data);        // If you want to reverse the process simply pass true for the `swap_conversion_table_key_value` argument        recursiveConvertKeys(resultant_data, conversion_table, true);        console.log(Back to normal Data:, resultant_data);    */    // Start at the root of the objects when we invoke this method    __current_object_level = __is_recursive_iteration ? __current_object_level : data_object;    __current_conversion_table_level = __is_recursive_iteration ? __current_conversion_table_level : conversion_table;    if(typeof __current_object_level == object)    {        // Make the iterate object        var iterate_object = Object.keys(__current_object_level);        //console.log('iter', iterate_object);        iterate_object.map(function(key, index, array) {            // Check to make sure this is part of the object itself            if (__current_object_level.hasOwnProperty(key))            {                if(__current_conversion_table_level)                {                    var new_key = null;                    if(!swap_conversion_table_key_value)                    {                        if(typeof __current_conversion_table_level[key] == object)                            new_key = __current_conversion_table_level[key]['_short'];                        else                            new_key = __current_conversion_table_level[key];                    }                    else                    {                        // We have to search through all of the current level to match the value to curernt object key since we swapped                        var table_level_keys = Object.keys(__current_conversion_table_level);                        for(var i = 0; i < table_level_keys.length; i++)                        {                            var curr_level_table_key = table_level_keys[i];                            var key_to_compare = null;                            var curr_level_table_value = __current_conversion_table_level[curr_level_table_key];                            if(typeof curr_level_table_value == object)                                key_to_compare = curr_level_table_value['_short'];                            else                                key_to_compare = curr_level_table_value;                            // If it is a match, we found it :)                            if(key_to_compare == key)                            {                                // Now use the key from the conversion table instead of the value                                new_key = curr_level_table_key;                                // Break out of the for loop after we found it                                break;                            }                        }                    }                    // If there is actually a new key, replace it in our object                    if(new_key)                    {                        renameProperty(__current_object_level, key, new_key);                    }                    //console.log('key', key, new_key);                    // Only keep going if there actually was a new_key                    // Or there is a array to look through the items on                    var is_current_key_array_index = key%1 == 0; // If the current key is a positive integer, we assume it is an array key                    if(new_key || is_current_key_array_index)                    {                        // Use the new key if it was available                        // Because that is what the object property is changed to from above                        var value = __current_object_level[new_key ? new_key : key];                        //console.log('current', value, __current_conversion_level);                        // If we are swapping then the `key` will not be found in the table as it is ass-backwards.                        var table_key = swap_conversion_table_key_value ? new_key : key;                        // If the current key is a array, maintain the `_array_item` conversion level we set the level prior                        // Otherwise continue down the tree                        var next_conversion_level = is_current_key_array_index ? __current_conversion_table_level : __current_conversion_table_level[table_key];                        if(typeof __current_conversion_table_level[table_key] == object)                        {                            // If the current value is an array set up the conversion level for the items                            if(Object.prototype.toString.call(value) === '[object Array]')                            {                                next_conversion_level = __current_conversion_table_level[table_key]['_array_item'];                            }                            else                            {                                next_conversion_level = __current_conversion_table_level[table_key]['_object'];                            }                        }                        //console.log('next', next_conversion_level);                        recursiveConvertKeys(data_object, conversion_table, swap_conversion_table_key_value, true, value, next_conversion_level);                    }                }            }        });    }}The format for the conversion table is below. I am not set on this format so feel free to suggest something better for the table/map.var conversion_table = {    psdf: p,     qwer: q,    dict: {        _short: d,        _object: {            one: o,            two: t,            three: r        }    },    candidates: {        _short: c,        _array_item: {            ip: i,            port: p        }    }}And some accompanying test data:var test_data = {    psdf: pcodereview,    qwer: qcodereview,    dict: {        one: 1,        two: 2,        three: 3    },    candidates: [        {            ip: 0.0.0.0,            port: 65000        },        {            ip: 127.0.0.1,            port: 65000        }    ]}    
Convert Object Keys according to Table/Map object
javascript;json;hash table
Great question,Can you take the truth?The real answer is that this is overkill. Send your JSON to other machines/clients with HTTP compression (gzip) and the benefits of slimming down are close to non-existing.Divide and conquerStill, this is a fun question. After looking at this for a while, I've come to the conclusion that you have so much code because you tried too hard to apply DRY. Converting keys and reverting keys are different enough to deserve separate functions. They will look tantalizingly similar, but I am quite sure that merging them is wrong.Naming conventionFurthermore, stop using _ and __ as prefixes to variables, it is not idiomatic for JavaScript. And start using lowerCamelCase, so __is_recursive_iteration should be isRecursiveIteration.Name that thingFurthermore, to quote Humpty DumptyWhen I use a word, Humpty Dumpty said, in rather a scornful tone,  it means just what I choose it to meanneither more nor less. The  question is, said Alice, whether you can make words mean so many  different things. The question is, said Humpty Dumpty, which is to  be masterthat's all.   Lewis CarrollWhen you declare curr_level_table_key it is the only 'key' in the scope, feel free to declare it simply as key, this would make your code far easier to understand. If you are not comfortable because it does not convey enough info, you could comment it (I would not do this personally):var key = table_level_keys[i]; //Current level table key <- That does not really make sense to meCommentingAlso your commenting is too excessive for what really should be a simple, recursive, key swapping algorithm. At least convert your 2 line comments to 1 line comments, remove obvious comments, and all remaining multi line comments should go in front of the function.Worst offender:// Break out of the for loop after we found itbreak;Avoid the arrow patternYou know that things are getting too complex when you see the arrow pattern, like here:                        //console.log('next', next_conversion_level);                        recursiveConvertKeys(data_object, conversion_table, swap_conversion_table_key_value, true, value, next_conversion_level);                    }                }            }        });    }}In this particular case you can do this by using the continue statement if you know that nothing else must be done in the loop, so consider usingif (!object.hasOwnProperty(key)){  continue;}HousekeepingRemove commented out code, your code is already hard to read and follow.Counter proposal// from: http://stackoverflow.com/a/4648411/796832// Check for the old property name to avoid a ReferenceError in strict mode.function renameProperty(object, oldName, newName) {  if (object.hasOwnProperty(oldName)) {    object[newName] = object[oldName];    delete object[oldName];    return object[newName];  }}function convertKeys(object, map) {  if (typeof object != object) {    return;  }  //Iterate over the object  Object.keys(object).map(function(key) {    var mappedKey = map[key];    if (!mappedKey) {      return;    }    var value = object[key];    if (mappedKey instanceof Object) {      if (mappedKey._short) {        value = renameProperty(object, key, mappedKey._short);      }      if (value instanceof Array) {        for (var i = 0, length = value.length; i < length; i++) {          convertKeys(value[i], mappedKey._array_item);        }      } else if (value instanceof Object) {        convertKeys(value, mappedKey._object);      }    } else {      renameProperty(object, key, mappedKey);    }  });}function findValueKey(object, searchValue) {  var keys = Object.keys(object), key, value;    for (var i = 0, length = keys.length; i < length; i++) {    key = keys[i];    value = object[key];       if (value === searchValue) {      return key;    }    if( value instanceof Object && value._short == searchValue ){      return key;    }  }}function revertKeys(object, map) {  if (typeof object != object) {    return;  }  //Iterate over the object  Object.keys(object).forEach(function(key) {    var mappedKey = findValueKey(map, key);    if (!mappedKey) {      return;    }    var value = renameProperty(object, key, mappedKey),        subMap = map[mappedKey];    if (subMap instanceof Object) {      if (value instanceof Array) {        for (var i = 0, length = value.length; i < length; i++) {          revertKeys(value[i], subMap._array_item);        }      } else if (value instanceof Object) {        revertKeys(value, subMap._object);      }    }  });}$('textarea').tabOverride();$('.go').on('click', function() {  // Tests  // ---------------------------  var data = JSON.parse($('.data-box').val());  var conversion_table = JSON.parse($('.conversion-table-box').val());  // Clone the data so we don't overwrite it  var resultant_data = $.extend(true, {}, data);  // Now execute the key converting process  convertKeys(resultant_data, conversion_table);  $('.result').html(JSON.stringify(resultant_data, null, '\t'));  console.log(Reversed Data:, resultant_data);  // If you want to reverse the process simply pass true for the `swap_conversion_table_key_value` argument  revertKeys(resultant_data, conversion_table);  $('.result-back-to-normal').html(JSON.stringify(resultant_data, null, '\t'));  console.log(Back to normal Data:, resultant_data);}).trigger('click');*, *:before, *:after {    -moz-box-sizing: border-box;    -webkit-box-sizing: border-box;    box-sizing: border-box;}html, body{    width: 100%;    height: 100%;    margin: 0;    padding: 0;        font-family: Arial, sans-serif;}pre, textarea {    tab-size: 4;    -moz-tab-size: 4;    -o-tab-size: 4;    -webkit-tab-size: 4;}textarea, pre{    width: 100%;    min-height: 150px;        padding: 4px;}.side-by-side-section{    display: flex;}.side-by-side-section > *{    flex: 1;}.code-block{    background: rgba(0, 0, 0, 0.1);    border: 1px solid rgba(0, 0, 0, 0.2);}<!DOCTYPE html><html><head><meta name=description content=Map keys /><script src=//code.jquery.com/jquery-2.1.1.min.js></script><script src=//rawgit.com/wjbryant/taboverride/master/build/output/taboverride.js></script><script src=//rawgit.com/wjbryant/jquery.taboverride/master/src/jquery.taboverride.js></script>  <meta charset=utf-8>  <title>JS Bin</title></head><body><button class=go>Go</button>Write data and conversion table in JSON.<br /><div class=side-by-side-section>    <div>        <div>Data:</div>        <textarea class=data-box>{ psdf: pcodereview, qwer: qcodereview, dict: {  one: 1,  two: 2,  three: 3 }, candidates: [  {   ip: 0.0.0.0,   port: 65000  },  {   ip: 127.0.0.1,   port: 65000  } ]}            </textarea>    </div>    <div>        <div>Conversion table:</div>        <textarea class=conversion-table-box>{ psdf: p,  qwer: q, dict: {  _short: d,              _object: {   one: o,   two: t,   three: r  } }, candidates: {  _short: c,  _array_item: {   ip: i,   port: p  } }}        </textarea>    </div></div><div class=side-by-side-section>    <div>        <div>Converted:</div>        <pre class=code-block><code class=result></code></pre>    </div>    <div>        <div>Converted back:</div>        <pre class=code-block><code class=result-back-to-normal></code></pre>    </div></div></body></html>