I have implemented functions that will let me reverse a one-to-many value 'Map', that is a plain JavaScript object.
For example,
var map = {'foo': 'bar', 'baz': 'bar', 'moo': 'zoo'};
becomes
var reversedMap = {'zoo': ['moo'], 'bar': ['foo', 'baz']}
and also a function to bring back reversed map to a non-reversed map.
Here's a jsbin to show that my solution is working.
In the following code I have used lo-dash utility toolbelt, but you need not be acquainted with it in order to understand the code. Assume that I trust in performance of lo-dash and what I'm trying to optimize is my own code.
Just for sake of clarity, _.forOwn
iterates over object's own properties, and _.forEach
iterates over each element of an array.
var identity = function(x) {return x;};
var reverseMapFromMap = function(map, callback) {
callback = callback || identity; //callback helps to parseInt numeric values, otherwise every object key is a string by default
var reversedMap = {};
_.forOwn(map, function(value, key) {
key = callback(key);
if (_.isUndefined(reversedMap[value]))
reversedMap[value] = [key];
else
reversedMap[value].push(key);
});
return reversedMap;
};
var mapFromReverseMap = function(reverseMap, callback) {
callback = callback || identity;
var map = {};
_.forOwn(reverseMap, function(revMembers, revKey) {
_.forEach(revMembers, function(revMember) {
map[revMember] = callback(revKey);
});
});
return map;
};
I'm pretty confident in my solution as it's quite basic, but as it is a frequent part of my code, I'd like to know if you can see any ways to improve performance, or alternatively if there's a better way to solve this problem.
Object.fromEntries(Object.entries(hash).map(entry => entry.reverse()))
. \$\endgroup\$