我想比较两个 json 对象，不包括其中一个键

Question

我有两个对象 x，y，我想比较这两个对象，不包括其中一个键“c”

let x = {a: 5, b: 6, c: "string"}
let y = {a: 5, b: 8, c: "string"}

我想如何比较它 -

JSON.stringify(x) === JSON.stringify(y)

上面的工作原理，但它会比较我想在此处比较时排除 c 的所有键。实现这一目标的最佳方法是什么？

Answer 1

以下代码从对象x中获取所有键，从列表中删除c，然后执行比较。

let x = { a: 5, b: 6, c: "string" };
let y = { a: 5, b: 6, c: "another string" };

console.log(
  Object.keys(x)
    .filter((key) => key !== "c")
    .every((key) => x[key] === y[key])
);

Answer 2

array.sort 需要一个比较器函数。你可以在这里使用完全相同的东西

function myObjComparator (x, y) {
  if (x.a != y.a) return y.a - x.a;
  return y.b - x.b;
}

Answer 3

一般来说，我不会为了比较它们而对对象进行字符串化。
原因很简单，就是必须确保成员的顺序相同，否则结果将不正确。

例如：

// objects are equals
const y = { a: '1', b: '2' }
const x = { b: '2', b: '1' }
// but result is not what you expect
JSON.stringify(x) === JSON.stringify(y) // false

但是，如果您可以确保成员的顺序始终相同，则 stringify 速度很快并且是一个不错的选择。

您可以按顺序使用扩展语法避免“c”属性

const remappedX = { ...x, c: undefined };
const remappedY = { ...y, c: undefined };
JSON.stringify(remappedX) === JSON.stringify(remappedY); // true

或者更通用

const allowedKeys = Object.keys(x).filter((k) => k !== 'c');
JSON.stringify(x, allowedKeys) === JSON.stringify(y, allowedKeys);

的方法是循环遍历对象键或条目

for(const key of Object.keys(x)) {
   if (key === 'c') {
      continue;
   }
   if (x[key] !== y[key]) {
         return false;
   }
}
return true;

但是，如果您的对象是嵌套的，则需要使用深度相等算法，这当然会更慢。

此处给出了更通用的答案

Answer 4

感谢大家对我的问题的快速答复，但下面是一个简单的方法，我可以通过它来实现上述逻辑

import omit from "lodash/omit";
import isEqual from "lodash/isEqual";

let x = {a: 5, b: 6, c: "string"},
y = {a: 5, b: 8, c: "string"}

result = isEqual(omit(x, ['c']), omit(y, ['c']))

Answer 5

这又如何呢？

JSON.stringify(x, ['a','b']) === JSON.stringify(y, ['a','b']);

更好的解决方案：

function replacer(key, value) {
  // Filtering out properties
  if (key === 'c') {
    return undefined;
  }
  return value;
}
JSON.stringify(x, replacer) === JSON.stringify(y, replacer);

更正 更好的解决方案：

const filterKeys = (obj) => Object.keys(y).filter(k => k !== 'c').sort()
JSON.stringify(x, filterKeys(x)) === JSON.stringify(y, filterKeys(y));

Answer 6

使用三元运算符来比较两个对象。

演示：

let x = {a: 5, b: 6, c: "string"};
let y = {a: 5, b: 8, c: "string"};

function compare(obj1, obj2) {
  return (obj1.a != obj2.a) ? false : (obj1.b != obj2.b) ? false : true;
}

console.log(compare(x, y));

通过删除不需要的属性，然后使用 JSON.stringify() 进行比较

演示：

let x = {a: 5, b: 6, c: "string"};
let y = {a: 5, b: 8, c: "string"};

delete x.c;
delete y.c;

console.log(JSON.stringify(x) === JSON.stringify(y));

Answer 7

这是一个解决方案

const x = {a: 5, b: 8, c: "string1", d: {e: 9}}
const y = {a: 5, b: 8, c: "string2", d: {e: 9}}

const compare = (obj1, obj2, except = []) => {
    
    if (Object.keys(obj1).length < Object.keys(obj2).length) {
        [obj1, obj2] = [obj2, obj1];
    }
    
    for (const obj1Key in obj1) {
        if (except.includes(obj1Key)) continue;

        if (!obj2.hasOwnProperty(obj1Key)) return false;

        if (typeof obj1[obj1Key] === 'object') {
            if (typeof obj2[obj1Key] !== 'object') return false;
            
            const isEqual = compare(obj1[obj1Key], obj2[obj1Key]);
            
            if (isEqual) continue
            
            return false;
        }

        if (obj1[obj1Key] !== obj2[obj1Key]) return false;
    }
    
    return true;
}

console.log(compare(x, y, ['c']));