在Javascript中删除对象中具有相同值（即重复值）的键/值对

我目前正在学习JS，我需要一种方法来返回与给定对象相似的对象，但删除具有相同值（即重复项）的键/值对

如果我有一个给定的对象{a:1，b:2，c:3，d:1}：

它应返回：

{b:2，c:3}

类似地，如果一个对象中的所有键值对具有不同的值，则返回的对象将与给定的对象相同

我想我已经接近解决这个问题了，但是我不知道我的代码出了什么问题。任何帮助都将不胜感激

const noDuplicateValues = (obj) => {
  let result = {};
  let keys = Object.keys(obj);
  let duplicate;

  for(let i = 0; i < keys.length; i++) {
    for(let j = i +1; j < keys.length; j++) {
      duplicate = false;
      if(obj[keys[i]] === obj[keys[j]]) {
        duplicate = true;
      }
    }
    if(!duplicate) {
      result[keys[i]] = obj[keys[i]];
    } 
  }
  return result;
}

const nodeuplicatevalues=（obj）=>{
让结果={}；
设keys=Object.keys（obj）；
让我们复制；
for（设i=0；i

我会计算每个值出现的次数，然后根据给定条目的值是否只出现一次来过滤对象条目：

constobj={a:1，b:2，c:3，d:1}；
常量引用=新映射（）；
for（对象值的常量值（obj））{
事件集（val，（事件集）get（val）| | 0）+1）；
}
const newObj=Object.fromEntries(
Object.entries（obj）
.filter（（[，val]）=>出现次数。获取（val）==1）
);
console.log（newObj）为了加快速度，您的内部循环可以在发现重复项后立即退出。但妨碍其正常工作的缺陷是，虽然它发现
a
是
d
的副本，并正确地忽略了
a
，但它没有忽略
d
，因为当它检查数组中的最后一个元素
d
时，没有后续元素可供比较，所以它不认为<代码> d>代码>是重复的。

解决方法是让内部循环检查每个元素（不仅仅是外部循环检查的元素之后的元素），当然要小心不要检查元素本身：

const noDuplicateValues = (obj) => {
    let result = {};
    let keys = Object.keys(obj);
    let duplicate;

    for (let i = 0; i < keys.length; i++) {
        duplicate = false;
        for (let j = 0; j < keys.length; j++) {
            if (
                i !== j // Don't compare an element with itself
                &&
                obj[keys[i]] === obj[keys[j]]
            ) {
                duplicate = true;
                break; // Found a dupe so we can stop checking this one for dupes
            }
        }
        if (!duplicate) {
            result[keys[i]] = obj[keys[i]];
        }
    }
    return result;
}

var x = noDuplicateValues({ a: 1, b: 2, c: 3, d: 1 });
console.log(x); // Object { b: 2, c: 3 }

const nodeuplicatevalues=（obj）=>{
让结果={}；
设keys=Object.keys（obj）；
让我们复制；
for（设i=0；i
您的代码有两个问题。
第一个是
duplicate
的值在内部循环中设置为
false
，而应该在外部循环中设置。
第二个问题是内部循环仅从
i+1
开始。因此，它实际上进行了以下比较：


a
vs
b
，
a
vs
c
，
a
vs
d
b
vs
c
，
b
vs
d
c
vs
d

因此，您还需要比较
d
与
a
、
b
、
c
的值。所以像这样的事情应该很有希望奏效

const noDuplicateValues = (obj) => {
  let result = {};
  let keys = Object.keys(obj);
  let duplicate;

  for(let i = 0; i < keys.length; i++) { 
    duplicate = false;
    for(let j = 0; j < keys.length; j++) {
      
      if(i !== j && obj[keys[i]] === obj[keys[j]]) {
        duplicate = true;
      }
    }
    if(!duplicate) {
      result[keys[i]] = obj[keys[i]];
    } 
  }
  return result;
}

const nodeuplicatevalues=（obj）=>{
让结果={}；
设keys=Object.keys（obj）；
让我们复制；
对于（设i=0；i

但如果您只跟踪值和发生次数，则效率会更高：1:2次、2:1次、3:1次。。。
然后，可以删除该值出现超过1次的所有键值对。这样，您只需在所有属性中循环一次。
为什么它应该删除
a
和
d
我正在做一个练习，要求返回一个删除具有相同值的键值对的对象。由于a和d的值均为1，因此将从返回的对象中删除它