根据索引删除数组中重复的组合

如何解决根据索引删除数组中重复的组合

我有以下数据数组：

const data = [
  {
    value: [
      'a','b','a','a'
    ]
  },{
    value: [
      'c','c','d','c'
    ]
  }
];

根据索引，这里有4种组合：
组合1：a-c（每个值数组中的索引0）
组合2：b-c（每个值数组中的索引1）
组合3：a-d（每个值数组中的索引2）
组合4：a-c（每个值数组中的索引3）

如您所见，第一个和最后一个组合是相同的，所以我想从每个数组中删除第二个组合，结果应该是：

    [
        {
        value: [
          'a','a'
        ]
      },{
        value: [
          'c','d'
        ]
      }
  ]

解决方法

您可以将两个对象的values数组压缩成一个看起来像这样的数组：

["a-c","b-c",...]

由于这些现在是字符串，因此可以使用new Set()将此数组转换为Set，这将删除所有重复出现的事件。然后，您可以将此集合变回数组，然后可以使用.reduce()来构建对象数组。对于每个值，您可以使用.split()上的'-'获得值列表，然后从中填充精简数组。

请参见以下示例：

const data = [{ value: [ 'a','b','a','a' ] },{ value: [ 'c','c','d','c' ] } ];

const unq = [...new Set(
  data[0].value.map((_,c)=> data.map(({value})=>value[c]).join('-')) 
)];
const res = unq.reduce((acc,str) => {
  const values = str.split('-');
  values.forEach((value,i) => acc[i].value.push(value));
  return acc;
},Array.from({length: data.length},_ => ({value: []})))
console.log(res);

上述方法的局限性假定您不会将-字符用作字符串值。如果这是一个问题，则可以考虑使用其他定界符，或者使用.filter()而不是Set在数组中查找唯一值。

,

您可以为基于索引的唯一值对保存一个查找对象

鉴于您的输入，下面的解决方案可以为您提供帮助

const data = [
  {
    value: ["a","b","a","a"],},{
    value: ["c","c","d","c"],]

const lookup = {}

data[0].value.forEach((_,index) => {
  lookup[`${data[0].value[index]}-${data[1].value[index]}`] = true
})

const res = Object.keys(lookup).reduce(
  (acc,key) => {
    const [val1,val2] = key.split("-")
    acc[0].value.push(val1)
    acc[1].value.push(val2)
    return acc
  },[{ value: [] },{ value: [] }]
)

console.log(res)

,

下面是具有生成器功能和单次通过的两步解决方案。

const data = [ { value: [ 'a',] } ];

const zipDataValues = function* (data) {
  const iterators = data.map(item => item.value[Symbol.iterator]())
  let iterations = iterators.map(iter => iter.next())
  while (iterations.some(iteration => !iteration.done)) {
    yield iterations.map(iteration => iteration.value)
    iterations = iterators.map(iter => iter.next())
  }
}

const filterOutDuplicateCombos = function (values) {
  const combosSet = new Set(),resultData = [{ value: [] },{ value: [] }]
  for (const [valueA,valueB] of values) {
    const setKey = [valueA,valueB].join('')
    if (combosSet.has(setKey)) {
      continue
    }
    combosSet.add(setKey)
    resultData[0].value.push(valueA)
    resultData[1].value.push(valueB)
  }
  return resultData
}

console.log(
  filterOutDuplicateCombos(zipDataValues(data))
) // [ { value: [ 'a','d' ] } ]

这里是generators and iterators

上的参考 ,

过滤器组合+按首次出现排序：

const data = [{
  value: ['a','a']
},{
  value: ['c','c']
}];

var res = {},i,t;

for (i = 0; i < data[0].value.length; ++i) {
  res[data[0].value[i]] = res[data[0].value[i]] || {};
  res[data[0].value[i]][data[1].value[i]] = true;
}

data[0].value = [];
data[1].value = [];

for (i in res) {
  for (t in res[i]) {
    data[0].value[data[0].value.length] = i;  
    data[1].value[data[1].value.length] = t;  
  }
}

console.log(data);