I have implemented a recursive function that converts an objects 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 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](http://jsfiddle.net/MadLittleMods/g3g0g1L4/)


![](https://i.imgur.com/8eOeQzz.png)

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:

    function recursiveConvertKeys(data_object, conversion_table, swap_conversion_table_key_value, __is_recursive_iteration, __current_object_level, __current_conversion_table_level)
    {
    	/* 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);
    	*/
    	//
    	// Do not pass in parameters for the double underscore arguments. These are private and only used for self recursive calling
    
    
    	// 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",
    	"array": {
    		"_short": "a"
    	},
    	"candidates": {
    		"_short": "c",
    
    		"_array_item": {
    			"ip": "i",
    			"port": "p"
    		}
    	}
    }

And some accompanying test data:

    var test_data = {
    	"psdf": "pcodereview",
    	"qwer": "qcodereview",
    	"array": [
    		"1",
    		"2",
    		"3"
    	],
    	"candidates": [
    		{
    			"ip": "0.0.0.0",
    			"port": 65000
    		},
    		{
    			"ip": "127.0.0.1",
    			"port": 65000
    		}
    	]
    }