使用相同的键进行分组，并用逗号连接值答案

【问题标题】：Group by using same key and join value with comma使用相同的键进行分组，并用逗号连接值
【发布时间】：2019-08-12 05:34:38
【问题描述】：

我有以下带有动态键/值对的示例数据，我需要用相同的键对它们进行分组，并用逗号连接多个值。我能够提取数组上的唯一键然后卡住了

输入

[
          {
            "c1": "USA"
          },
          {
            "c2": "Korea"
          },
          {
            "c4": "japan"
          },
          {
            "c3": "india"
          },
          {
            "c1": "australia"
          },
          {
            "c2": "france"
          }
        ]

输出

[
          {
            "c1": "USA,australia",
            "c2": "Korea,france",
            "c4": "japan",
            "c3": "india"
          }
        ]

let data=[
      {
        "c1": "USA"
      },
      {
        "c2": "Korea"
      },
      {
        "c4": "japan"
      },
      {
        "c3": "india"
      },
      {
        "c1": "australia"
      },
      {
        "c2": "france"
      }
    ]
    
    var output = Object.keys(data).map(element => {
    
      var ret = Object.keys(data[element]);
      
      return ret;
    
    })
    let c=[...new Set(output.flat())];
    console.log(c);

如何用逗号从我得到的唯一数组中加入值，我想我是一半

【问题讨论】：

操纵map() 来构建和返回新的对象比较键。你已经成功了一半。

标签： javascript arrays dictionary reduce

【解决方案1】：

您需要借助 map() 函数输出一个新的有组织的对象。

没有检查代码 - 但它应该看起来像这样。

 let dataNew = {};
 var output = Object.keys(data).map(element => {
      if (typeof( dataNew[element] ) === 'undefined') {
        dataNew[element] = data[element]
      } else {
        dataNew[element] += `,${data[element]}`;
      }
      return dataNew;
    })

像这样，您正在创建一个具有统一值的逗号的新对象。

【讨论】：

【解决方案2】：

你可以试试 Array.reduce 原型

let data=[
      {
        "c1": "USA"
      },
      {
        "c2": "Korea"
      },
      {
        "c4": "japan"
      },
      {
        "c3": "india"
      },
      {
        "c1": "australia"
      },
      {
        "c2": "france"
      }
    ]

const combinedData = data.reduce((memory, current) => {
	const currentKeys = Object.keys(current);
	const found = memory.find(m => 
		Object.keys(m).some(key => currentKeys.includes(key))
	);

	if (found) {
		const key = Object.keys(found).pop();
		found[key] = `${found[key]},${current[key]}`;
    } else {
		memory.push(current);
    }

	return memory;

}, []);

console.log(combinedData);

【讨论】：

【解决方案3】：

获取键值对，将它们展平（因为键是否在同一个对象中并不重要），然后使用另一个对象进行合并：

 const result = input
  .map(Object.entries)
  .flat()
  .reduce((obj, [k, v]) => ((obj[k] = obj[k] ? (obj[k] + ", " + v) : v), obj), {});

【讨论】：

【解决方案4】：

抱歉，我返回并删除了最终数组的重复数据。

const data = [
  {
    "c1": "USA"
  },
  {
    "c2": "Korea"
  },
  {
    "c4": "japan"
  },
  {
    "c3": "india"
  },
  {
    "c1": "australia"
  },
  {
    "c2": "france"
  }
]

let endData = [{}]

data.forEach(d => {
  const [dataKey] = Object.keys(d)
  const relatedValues = data.map(d => dataKey in d ? d[dataKey] : null).filter(Boolean)
  const combinedValues = [d[dataKey], ...relatedValues]
  
  const unique = endData.find(d => Object.keys(d)[0] === dataKey) === undefined
  if (unique) endData[0][dataKey] = `${[...new Set(combinedValues)]}`
})

console.log(endData)

【讨论】：

它有重复的值
@eagerleaner 那更好吗？
您的预期输出是一个数组，里面有一个对象（就像我提供的那样）有必要吗？或者endData 可以只是一个对象。

【解决方案5】：

在不更改代码的情况下：遍历 Set c 的每个值，然后过滤具有相同 key 的数据项，然后将它们与 join (',') 合并。

let data=[
      {
        "c1": "USA"
      },
      {
        "c2": "Korea"
      },
      {
        "c4": "japan"
      },
      {
        "c3": "india"
      },
      {
        "c1": "australia"
      },
      {
        "c2": "france"
      }
    ]
    
    var output = Object.keys(data).map(element => {
    
      var ret = Object.keys(data[element]);
      
      return ret;
    
    })
    let c=[...new Set(output.flat())];
    
    /* Join equals */
    const n = []; 
    c.forEach( (it, idx) => {
      n.push({});
      n[idx][it] = data.filter(its => it === Object.keys(its)[0])
                  .map( its => Object.values(its)[0])
                  .join(',');
    })
    console.log(n);

【讨论】：