Javascript 比较两个对象并删除两个对象之间的重复关键点

我正在对象上进行实验，我试图实现的是删除

object1

中的键（如果这些键存在于

object2

中）

以下是一个例子：

var original = {
    a: 1, 
    b: 2, 
    c: 3,
    e: {
        tester: 0,
        combination: {
            0: 1
        }
    },
    0: {
        test: "0",
        2: "hello"
    }
};

var badKeys = {
    a: 1,
    b: 2,
    0: {
        test: "0",
    }
}


var expectedResult = {
    c: 3,
    e: {
        tester: 0, 
        combination: {
            0: 1
        }
    },
    0: {
        2: "hello"
    }

}

我尝试过使用

下划线

差分函数，但它不适用于对象，也不确定这是否是正确的函数

---

你能帮我把

var expectedResult

弄对吗？

你可以创建递归函数，使用

for…in

循环返回新对象

var-original={“0”：{“2”：“hello”，“test”：“0”}，“a”：1，“b”：2，“c”：3，“e”：{“tester”：0，“composition”：{“0”：1}}
var badKeys={“0”：{“test”：“0”}，“a”：1，“b”：2}
功能移除（o1，o2）{
var result={}
对于（o1中的var i）{
如果（！o2[i]）结果[i]=o1[i]
如果（o2[i]）{
if（类型o1[i]=“对象”和类型o2[i]=“对象”）{
result[i]=Object.assign（result[i]| |{}，remove（o1[i]，o2[i]））
}如果（o1[i]！=o2[i]）结果[i]=o1[i]
}
}
返回结果
}
log（remove（original，badKeys））

您可以使用迭代和递归方法在新对象中定位所需的属性

函数删除键（好、坏、结果）{
Object.keys（好）、forEach（函数（键）{
if（坏[键]&&typeof坏[键]=“对象”）{
结果[键]={}；
删除键（好[键]、坏[键]、结果[键]；
返回；
}
如果（！（输入坏）|好[键]！==坏[键]）{
结果[关键点]=良好[关键点]；
}
});
}
var original={a:1，b:2，c:3，e:{tester:0，组合：{0:1}}，0:{test:“0”，2:“hello”，另一个：{a:{b:2，c:{a:3}，b:2}，
坏键={a:1，b:2，0:{test:“0”，随机：2，另一个：{a:1}}，
结果={}；
删除密钥（原始、坏密钥、结果）；
控制台日志（结果）
.as控制台包装{max height:100%！important；top:0；}
这将是算法：

function removeDifferences (original, removeKeys) {
  // Get keys of to be deleted properties.
  var keys = Object.keys(removeKeys);

  // Iterate all properties on removeKeys.
  for (key of keys) {
    // Check if property exists on original.
    if (typeof original[key] !== undefined) {
      // If the property is an object, call same function to remove properties.
      if (typeof removeKeys[key] === 'object') {
        removeDifferences(original[key], removeKeys[key]);
      } else {
        delete original[key];
      }
    }
  }
  return original;
}

适用于您的情况：


/*您的数据*/
原始变量={
答:1,，
b:2，
c:3，
e:{
测试人员：0，
组合：{
0: 1
}
},
0: {
测试：“0”，
2：“你好”
}
};
var badKeys={
答:1,，
b:2，
0: {
测试：“0”，
}
};
var expectedResult={
c:3，
e:{
测试人员：0，
组合：{
0: 1
}
},
0: {
2：“你好”
}
};
/*作用*/
功能移除差异（原始、移除键）{
//获取要删除的属性的键。
var keys=Object.keys（removeKeys）；
//迭代removeKeys上的所有属性。
用于（钥匙中的钥匙）{
//检查原件上是否存在属性。
if（原始[键]！==未定义的类型）{
//如果属性是对象，则调用相同的函数以删除属性。
如果（移除键的类型[键]=='对象'）{
移除差异（原始[键]、移除键[键]）；
}否则{
删除原始[密钥]；
}
}
}
归还原件；
}
/*应用*/
var输出=移除的差异（原始、坏键）；
控制台日志（输出）
.as控制台包装{max height:100%！important；top:0；}
使用纯函数进行一些递归和一些函数编程确实是一项工作。（使用节点v7.7.1进行测试）

“DoForAllNestedObjects”，用于在baddict中有对应的“叶”时，对“字典树上的每个叶”应用某些函数“whattodo”

let DoForAllNestedValues = (dict, baddict, whattodo) => {
    for (let key in dict) {
        if (typeof (dict[key]) === 'object' && typeof (baddict[key]) === 'object')
            DoForAllNestedValues(dict[key], baddict[key], whattodo);
        else
            if (baddict[key])
                whattodo(dict, key);
    }
}

DoForAllNestedValues(original, badKeys, (obj, val) => delete obj[val]);
console.log(original);

结果是新对象吗？是的，这样会更好，但是使用原始对象也可以。如果要删除重复的关键点，为什么允许保留“0”？只有当值相同时才删除键吗？@RobG，因为有
“2:“您好“
Inside这不适用于嵌套属性超过3个的深度对象这里应该有另一个
对象。结果是一个
对象，因为值不相同，对吗？您的代码只适用于深度为3的对象，我的属性比4-5级更深我仍然无法使用它。。。可能是因为我正在使用nodejs吗？