Convert Object Keys according to Table/Map object

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: jsFiddle

Usage:

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 Gist

```
function 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, fals

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 conquer

Still, 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 convention

Furthermore, 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 thing

Furthermore, to quote Humpty Dumpty


"When I use a word," Humpty Dumpty said, in rather a scornful tone,
"it means just what I choose it to mean—neither 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 master—that's all.” ― Lewis Carroll

When 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 me

Commenting

Also 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 it
break;

Avoid the arrow pattern

You 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 using

if (!object.hasOwnProperty(key)){
  continue;
}

Housekeeping

Remove 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
, :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);
}



JS Bin

Go
Write data and conversion table in JSON.


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



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




Converted:
`


Converted back:

StackExchange Code Review Q#69651, answer score: 3