Question

我想知道如何删除比较它们的值的重复嵌套对象。

 const values = [ 
    { i: 2, j: 4, l: 36 },
    { i: 4, j: 2, l: 36 },
    { i: 0, j: 2, l: 28 },
    { i: 0, j: 4, l: 28 },
    { i: 1, j: 2, l: 28 },
    { i: 1, j: 4, l: 28 },
    { i: 2, j: 1, l: 28 },
    { i: 2, j: 3, l: 28 },
    { i: 2, j: 5, l: 28 },
    { i: 3, j: 2, l: 28 },
    { i: 3, j: 4, l: 28 },
    { i: 4, j: 1, l: 28 },
    { i: 4, j: 3, l: 28 },
    { i: 4, j: 5, l: 28 },
    { i: 5, j: 2, l: 28 },
    { i: 5, j: 4, l: 28 },
    { i: 0, j: 1, l: 20 },
    { i: 0, j: 3, l: 20 },
    { i: 0, j: 5, l: 20 },
    { i: 1, j: 3, l: 20 },
    { i: 1, j: 5, l: 20 },
    { i: 3, j: 1, l: 20 },
    { i: 3, j: 5, l: 20 },
    { i: 5, j: 1, l: 20 },
    { i: 5, j: 3, l: 20 } 
 ];

在这种情况下，我想删除第二个重复的对象（满足下面的条件），然后让第一个：

 value[i].i === value[j].j && value[i].j === value[i].i && value[i].l === 
 value[j].l

想要的结果：

 const result = [
    { i: 2, j: 4, l: 36 },
    { i: 0, j: 2, l: 28 },
    { i: 0, j: 4, l: 28 },
    { i: 1, j: 2, l: 28 },
    { i: 1, j: 4, l: 28 },
    { i: 2, j: 3, l: 28 },
    { i: 2, j: 5, l: 28 },
    { i: 3, j: 4, l: 28 },
    { i: 4, j: 5, l: 28 },
    { i: 0, j: 1, l: 20 },
    { i: 0, j: 3, l: 20 },
    { i: 0, j: 5, l: 20 },
    { i: 1, j: 3, l: 20 },
    { i: 1, j: 5, l: 20 },
    { i: 3, j: 5, l: 20 }
];

谢谢。

Answer 1

您可以将这些值作为组合键，并使用Set进行检查以进行过滤。

var values = [{ i: 2, j: 4, l: 36 }, { i: 4, j: 2, l: 36 }, { i: 0, j: 2, l: 28 }, { i: 0, j: 4, l: 28 }, { i: 1, j: 2, l: 28 }, { i: 1, j: 4, l: 28 }, { i: 2, j: 1, l: 28 }, { i: 2, j: 3, l: 28 }, { i: 2, j: 5, l: 28 }, { i: 3, j: 2, l: 28 }, { i: 3, j: 4, l: 28 }, { i: 4, j: 1, l: 28 }, { i: 4, j: 3, l: 28 }, { i: 4, j: 5, l: 28 }, { i: 5, j: 2, l: 28 }, { i: 5, j: 4, l: 28 }, { i: 0, j: 1, l: 20 }, { i: 0, j: 3, l: 20 }, { i: 0, j: 5, l: 20 }, { i: 1, j: 3, l: 20 }, { i: 1, j: 5, l: 20 }, { i: 3, j: 1, l: 20 }, { i: 3, j: 5, l: 20 }, { i: 5, j: 1, l: 20 }, { i: 5, j: 3, l: 20 }],
    s = new Set,
    filtered = values.filter(o => {
        var key1 = ['i', 'j', 'l'].map(k => o[k]).join('|'),
            key2 = ['j', 'i', 'l'].map(k => o[k]).join('|');
        return !s.has(key1) && !s.has(key2) && s.add(key1) && s.add(key2);
    });
    
console.log(values.length, filtered.length);
console.log(filtered);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 2

要通过交换密钥来处理条件

value[i].i === value[j].j && value[i].j === value[i].i

您可以创建两个函数来计算要测试的相等性值。一个不带交换，另一个带。您可以将原始文件添加到集合中，然后在过滤器测试中检查是否存在交换版本。

例如：

const values = [ 
  { i: 2, j: 4, l: 36 },
  { i: 4, j: 2, l: 36 },
  { i: 0, j: 2, l: 28 },
  { i: 0, j: 4, l: 28 },
  { i: 1, j: 2, l: 28 },
  { i: 1, j: 4, l: 28 },
  { i: 2, j: 1, l: 28 },
  { i: 2, j: 3, l: 28 },
  { i: 2, j: 5, l: 28 },
  { i: 3, j: 2, l: 28 },
  { i: 3, j: 4, l: 28 },
  { i: 4, j: 1, l: 28 },
  { i: 4, j: 3, l: 28 },
  { i: 4, j: 5, l: 28 },
  { i: 5, j: 2, l: 28 },
  { i: 5, j: 4, l: 28 },
  { i: 0, j: 1, l: 20 },
  { i: 0, j: 3, l: 20 },
  { i: 0, j: 5, l: 20 },
  { i: 1, j: 3, l: 20 },
  { i: 1, j: 5, l: 20 },
  { i: 3, j: 1, l: 20 },
  { i: 3, j: 5, l: 20 },
  { i: 5, j: 1, l: 20 },
  { i: 5, j: 3, l: 20 } 
];



const makeKey = (a) => `${a.i}_${a.j}_${a.l}`  // original key
const makeKey_test = (a) => `${a.j}_${a.i}_${a.l}` // considered a dupe

let found = new Set()
let filtered = values.filter(item => {
  if (found.has(makeKey_test(item))) return false
  found.add(makeKey(item))
  return true
})
console.log(filtered)
console.log("length:", filtered.length)

这将使您测试集合中是否包含具有交换密钥的版本，但不会找到具有相同i和j的“真实”重复对象

Answer 3

const values = [ 
    { i: 2, j: 4, l: 36 },
    { i: 4, j: 2, l: 36 },
    { i: 0, j: 2, l: 28 },
    { i: 0, j: 4, l: 28 },
    { i: 1, j: 2, l: 28 },
    { i: 1, j: 4, l: 28 },
    { i: 2, j: 1, l: 28 },
    { i: 2, j: 3, l: 28 },
    { i: 2, j: 5, l: 28 },
    { i: 3, j: 2, l: 28 },
    { i: 3, j: 4, l: 28 },
    { i: 4, j: 1, l: 28 },
    { i: 4, j: 3, l: 28 },
    { i: 4, j: 5, l: 28 },
    { i: 0, j: 3, l: 20 },
    { i: 5, j: 2, l: 28 },
    { i: 3, j: 1, l: 20 },
    { i: 5, j: 4, l: 28 },
    { i: 0, j: 1, l: 20 },
    { i: 0, j: 3, l: 20 },
    { i: 0, j: 5, l: 20 },
    { i: 1, j: 3, l: 20 },
    { i: 1, j: 5, l: 20 },
    { i: 3, j: 1, l: 20 },
    
    { i: 3, j: 1, l: 20 },
    { i: 3, j: 5, l: 20 },
    { i: 5, j: 1, l: 20 },
    { i: 5, j: 3, l: 20 } 
 ];
 
 let objData = values; 
 
values.sort(function(a, b){ return a['i'] - b['i'] || a['j'] - b['j'] || a['l'] - b['l'] ;  });

console.log(values);
let uniqueData = [], currentObj = {}, add;
currentObj = values[0];
uniqueData.push(currentObj);
for(let i = 1; i < values.length; i++){
   add = false;
   for(let j in values[i]){
      if(values[i][j] != currentObj[j]){
        add = true;
        break;
      }
   }
   if(add){
      currentObj = values[i];
      uniqueData.push(currentObj);
   }
}
console.log(uniqueData);

如何删除重复的嵌套对象并比较它们的值

3 个答案: