将具有相同值的对象键分组

Question

我有一个对象

var myObject = {"audi": "gas", "tesla": "electric", "bmw": "electric", "mercedes": "electric"}

我想将所有具有相同值的键分组在一个字符串中，就像只使用 es5

tesla bmw mercedes: electric. audi: gas

我使用了Object.keys和的组合，Object.values但对我不起作用

var res = ''
Object.keys(myObject).map(function(key) {
    Object.values(myObject).map(function(val) {
        if (myObject[key] === val) {
            kes = {
                [res.concat(key)]: val
            }
        }
    })
})

Answer 1

按“燃料”分组更有意义。为此，您可以使用reducer。

在片段中，通往罗马的几条不同道路......

也可以看看...

const logElem = document.querySelector(`pre`);
var myObject = {
  audi: "gas",
  tesla: "electric",
  bmw: "electric",
  mercedes: "electric"
};

const byFuel = Object.entries(myObject)
  .reduce((acc, [key, value]) =>
    ({ ...acc, [value]: (acc[value] || []).concat(key) }), {});

logElem.textContent = `***By fuel (ES6)***\n ${
  JSON.stringify(byFuel, null, 2)}`;

// to swap keys and values from [byFuel]
const byCars = Object.entries(byFuel)
  .reduce((acc, [key, value]) => ({ ...acc,
    [value.join(`,`)]: key
  }), {});

logElem.textContent += `\n\n***By cars from byFuel (ES6)***\n${
  JSON.stringify(byCars, null, 2)}`;

// Use one reducer (ES6)
const byCarsInOne = Object.entries(myObject)
  .reduce((acc, [key, value]) => {
    const keysAggregatedAsSingleKey = Object.keys(myObject)
      .filter( key => myObject[key] === value )
      .join(`,`);
    return acc[keysAggregatedAsSingleKey] 
      ? acc 
      : { ...acc, [keysAggregatedAsSingleKey]: value };
  }, {});

logElem.textContent += `\n\n***One reducer***\n${
  JSON.stringify(byCarsInOne, null, 2)}`;


// ES5 (really necessary? All modern browsers support es6)
var byFuelEs5 = {};
var byCarsEs5 = {};

for (var key in myObject) {
  var ky = myObject[key];
  byFuelEs5[ky] = ky in byFuelEs5 
    ? byFuelEs5[ky].concat(key) 
    : [key];
}

logElem.textContent += `\n\n***ES5***\n${
  JSON.stringify(byFuelEs5, null, 2)}`;

for (var key in byFuelEs5) {
  byCarsEs5[byFuelEs5[key].join(`,`)] = key;
}

logElem.textContent += `\n\n${
  JSON.stringify(byCarsEs5, null, 2)}`;

// Object.keys ES5, not very efficient
// (makes you *really* want to use ES6 ;)
var cars = Object.keys(myObject);
var byCarsEs5_2 = cars
  .map( function(key) {return [myObject[key], key]; })
  .map( function(kv) {
    var fuel = kv[0];
    var comma = this[fuel] ? "," : "";
    this[fuel] = (this[fuel] || "") + comma + kv[1];
    return this; }, {} )
  .map( function(obj) {
    var keys = Object.keys(obj)
      .map( key => this[obj[key]] = key );
    return this;
  }, {}).shift();
  
logElem.textContent += `\n\n***Object.keys and map ES5***\n${
      JSON.stringify(byCarsEs5_2, null, 2)}`;

// Finally, reduce from Object.keys my be more efficient
var byCarsEs5_3 = cars
  .reduce( function(acc, car) {
    var fuel = myObject[car];
    
    if (!~acc.fuels.indexOf(fuel)) {
      acc.fuels.push(fuel);
      var carsByFuel = cars.filter(key => myObject[key] === fuel);
      acc.result[carsByFuel] = fuel;
    }

    return acc; 
  }, {fuels: [], result: {}} ).result;

logElem.textContent += `\n\n***ES5 one reducer from  Object.keys***\n${
  JSON.stringify(byCarsEs5_3, null, 2)}`;

<pre></pre>