There is no such built-in function in JavaScript. Your code looks fine, but given that there are so many edge cases here that could wrong, I'd suggesting using invertBy from lodash, which does exactly what you describe.

Example

var object = { 'a': 1, 'b': 2, 'c': 1 };

_.invertBy(object);
// => { '1': ['a', 'c'], '2': ['b'] }

You could use reduce to save the declaration line reduce.

Abusing && to check if the map[object[key]] is defined first before using Array.concat.

It's shorter, but is it simpler? Probably not, but a bit of fun ;)

const reverseMapping = (object) => 
    Object.keys(object).reduce((map, key) => {
        map[object[key]] = map[object[key]] && map[object[key]].concat(key) || [key]
     return map;
    }, {});

You can use something like this to get raid of duplicates first :

function removeDuplicates(arr, key) {
   if (!(arr instanceof Array) || key && typeof key !== 'string') {
    return false;
   }

  if (key && typeof key === 'string') {
    return arr.filter((obj, index, arr) => {
        return arr.map(mapObj => mapObj[key]).indexOf(obj[key]) === index;
    });

  } else {
    return arr.filter(function(item, index, arr) {
        return arr.indexOf(item) == index;
    });
  }
} 

and then use this to make it reverse :

function reverseMapping(obj){
  var ret = {};
  for(var key in obj){
  ret[obj[key]] = key;
  }
    return ret;
  }

You could try getting an array of values and an array of keys from the current object, and setup a new object to hold the result. Then, as you loop through the array of values -

• if the object already has this value as the key, like Netherlands, you create a new array, fetch the already existing value (ex: Rotterdam), and add this and the new value (Amsterdam) to the array, and set up this array as the new value for the Netherlands key.
• if the current value doesn't exist in the object, set it up as a new string, ex: France is the key and Paris is the value.

Code -

const city2country = {
    'Amsterdam': 'Netherlands',
    'Rotterdam': 'Netherlands',
    'Paris': 'France',
};

function reverseMapping(obj) {
  let values = Object.values(obj);
  let keys = Object.keys(obj);
  let result = {}
  values.forEach((value, index) => {
    if(!result.hasOwnProperty(value)) {
      // create new entry
      result[value] = keys[index];
    }
    else {
      // duplicate property, create array
      let temp = [];
      // get first value
      temp.push(result[value]);
      // add second value
      temp.push(keys[index]);
      // set value 
      result[value] = temp;
    }
  });
  
  console.log(result);
  return result;
}

reverseMapping(city2country)

The benefit here is - it adjusts to the structure of your current object - Netherlands being the repeated values, gets an array as it's value in the new object, while France gets a string value Paris as it's property. Of course, it should be very easy to change this.

Note - Object.values() might not be supported across older browsers.

@Nina Scholz answer works well for this exact question. :thumbsup:

But if you don't need to keep both values for the Netherlands key ("Netherlands": ["Amsterdam", "Rotterdam"]), then this is a little bit shorter and simpler to read:

const city2country = { Amsterdam: 'Netherlands', Rotterdam: 'Netherlands', Paris: 'France' };

console.log(
  Object.entries(city2country).reduce((obj, item) => (obj[item[1]] = item[0]) && obj, {})
);
// outputs `{Netherlands: "Rotterdam", France: "Paris"}`

Inspired by some of the other answers, here is a short reusable function:

/**
 * Take an object with key->value mapping and return
 * an object with the inverse value->keys[] mapping.
 */
function invertObj(obj) {
  return Object.entries(obj)
    .reduce((result, [key, value]) => {
      result[value] = (result[value] || []).concat(key);
      return result;
    }, {});
}

Usage with the example from the question:

invertObj({
    'Amsterdam': 'Netherlands',
    'Rotterdam': 'Netherlands',
    'Paris': 'France'
});
// => {
//   "Netherlands": [ "Amsterdam", "Rotterdam" ],
//   "France": [ "Paris" ],
// }