对于符合 JSON 的对象文字数组，如何比较这些项的相等性？-解网

问：

如何使用 React.js 和打字稿检查数组是否包含不同的值？

例：

[{
  name: 'John',
  value: 1,
}, {
  name: 'John',
  value: 1,
}, {
  name: 'Carla',
  value: 15,
}]

如果数组中的所有对象都相同，我想返回 false，如果至少有一个不同的对象，我想返回 true。

JavaScript 数组对象比较相等

0赞 Peter Seliger 2/11/2021

代码示例显示的内容与打字稿和 reactjs 无关。

0赞 Peter Seliger 2/11/2021

对于任何方法，例如，获取第一个数组项，然后与所有其他项进行比较，需要以某种方式知道这些项的对象结构。如果它像上面所示一样简单，那么它可以通过比通常需要的更简单的对象比较来解决，以便通常涵盖更复杂的对象。

0赞 Heretic Monkey 2/11/2021

这回答了你的问题吗？如何在JavaScript对象数组中查找重复值，并仅输出唯一值？

0赞 Heretic Monkey 2/11/2021

另请参阅在 JavaScript 中，如何检查数组是否具有重复的多个值？

0赞 Peter Seliger 2/12/2021

@nlstmn......我贡献了另一种方法，它以最通用的方式涵盖了符合 JSON 的 JS 对象的比较。

答：

-1赞 Samuli Hakoniemi 2/11/2021 #1

我会通过引用复制的数组来检查字符串化对象数组是否包含字符串化项目，其中我删除了最新的项目。我将用于比较所有项目是否匹配在一起，然后返回相反的值。Array.every()

但是，如果对象数组非常长，这可能是非常繁重的操作

const arrSame = [{name: 1}, {name: 1}, {name: 1}];
const arrDiff = [{name:1}, {name: 2}, {name: 2}];
const arrDiff2 = [{name:1}, {name: 1}, {name: 2}];

const hasDifferentValues = (arr) => !arr.every((item, i, ref) => JSON.stringify([...ref].shift()).includes(JSON.stringify(item)));


console.log(hasDifferentValues(arrSame));
console.log(hasDifferentValues(arrDiff));
console.log(hasDifferentValues(arrDiff2));

2赞 Peter Seliger 2/11/2021

唯一可以肯定的是，这种方法适用于上述示例以及 OP 的示例。但它已经失败了，对后者稍作改动，比如比较自。{ name: 'John', value: 1 }{ value: 1, name: 'John' }

-1赞 ParthianShotgun 2/11/2021 #2

这并不完全是特定于反应的，但要检查差异，您可以使用每个类似的方法遍历数组。

const fooArray = [{
    name: 'John',
    value: 1,
    nest: {
      isValid: [1, 2]
    }
  },
  {
    value: 1,
    name: 'John',
    nest: {
      isValid: [1, 1]
    }
  }, {
    name: 'John',
    value: 1,
    nest: {
      isValid: [1, 1]
    }
  }
]

// check each member against the last, see if there is a diff
const isSame = (element, index, arr) => {
  if (index > 0) {
    // https://stackoverflow.com/questions/1068834/object-comparison-in-javascript
    // return JSON.stringify(element) === JSON.stringify(arr[index - 1])
    // alternatively, you can check to see if some of the values are different
    // by stringifying and checking if either are permuations of each other
    // this is probably not the ideal way, but I added it for the sake of a different solution
    const currentObStr = JSON.stringify(element).split("").sort().join()
    const prevObStr = JSON.stringify(arr[index - 1]).split("").sort().join()
    return currentObStr === prevObStr
  }
  return true
}

const everyElementIsSame = fooArray.every(isSame)
console.log(everyElementIsSame)

1赞 Heretic Monkey 2/11/2021

如果我将其中一个对象更改为这将失败。{ value: 1, name: 'John' }

1赞 Peter Seliger 2/11/2021

任何基于 do 的方法都会因对象键顺序的丝毫更改而失败。因此，比较结果例如会愚弄一个人，因为它说即使它应该是JSON.stringify{ name: 'John', value: 1 }{ value: 1, name: 'John' }falsetrue

0赞 ParthianShotgun 2/11/2021

@PeterSeliger我添加了一个解决方法来克服定位问题。我投票赞成马特的答案，因为我认为这是最“不笨拙”的。我做了一些我自己直觉的事情，为了有不同的方法。

0赞 Peter Seliger 2/12/2021

我认为拆分和重新组合 JSON 字符串的更新更像是一种黑客攻击，而不是解决方案，因为它恰好涵盖了 JSON 符合对象的第一级，但对于新手来说可能会导致错误地认为它可以做更多的事情。

1赞 ParthianShotgun 2/12/2021

@PeterSeliger啊，我明白了，这就是我所缺少的。既然你说了，这很有道理，我的排序是从对象中剥离意义，只是将所有数据放在同一行中，绝对不是一个可持续的解决方案。

2赞 Matt Wills 2/11/2021 #3

不能使用直接相等比较，因为对象永远不会返回相等。

即，和！= 。{} != {}{name: 'John', value: 1}{name: 'John', value: 1}

因此，首先，您必须决定要为这些对象定义什么为“相等”。

为了这个原因，我们假设你只使用字段作为平等的测试。因此，如果数组中的两个对象具有相同的字段，那么您将称它们相等。然后，您将定义函数：namename

type NameValue = {name: string, value: string}

const areEqual = (obj1: NameValue, obj2: NameValue): boolean => obj1.name === obj2.name

当然，您可以更改此函数以反映您定义为“相等”的任何内容。也有 npm 包可以帮助您进行深度相等性检查，或者您可以 JSON.stringify 两者并检查相等性

然后你可以使用 Array.some（）。如果数组中的任何元素通过测试，Array.some（）将返回 true。https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some

测试是否有任何元素不等于第一个元素就足够了。

const areNotAllEqual = yourArray.some((currentElement) => {
  return !areEqual(currentElement, yourArray[0])
})

0赞 Peter Seliger 2/11/2021

迄今为止的最佳答案，特别是因为更详细的背景信息

2赞 Peter Seliger 2/12/2021 #4

在评论和批评了基于的方法之后，我想就此事做出一些贡献。由于与此同时，所有现代 JS 引擎似乎都知道对象的键顺序（该对象的创建方式），并且似乎也保证了键迭代的顺序，因此可以编写一个递归函数，对于任何深度嵌套但符合 JSON 的 JS 对象，该函数会为此类对象重新建立规范化的键顺序，但不会触及数组。JSON.stringify

然后，将此类键规范化对象传递给这些对象，使其具有字符串化签名的可比性......JSON.stringify

function defaultCompare(a, b) {
  return ((a < b) && -1) || ((a > b) && 1) || 0;
}
function comparePropertyNames(a, b) {
  return a.localeCompare
    ? a.localeCompare(b)
    : defaultCompare(a, b);
}

function getJsonDataWithNormalizedKeyOrder(data) {
  let value;
  if (Array.isArray(data)) {

    value = data.map(getJsonDataWithNormalizedKeyOrder);

  } else if (data && (typeof data === 'object')) {

    value = Object
      .getOwnPropertyNames(data)
      .sort(comparePropertyNames)
      .reduce((obj, key) => {
        obj[key] = getJsonDataWithNormalizedKeyOrder(data[key])
        return obj;
      }, {});

  } else {

    value = data;
  }
  return value;
}


const objA = {
  name: 'foo',
  value: 1,
  obj: {
    z: 'z',
    y: 'y',
    a: {
      name: 'bar',
      value: 2,
      obj: {
        x: 'x',
        w: 'w',
        b: 'b',
      },
      arr: ['3', 4, 'W', 'X', {
        name: 'baz',
        value: 3,
        obj: {
          k: 'k',
          i: 'i',
          c: 'c',
        },
        arr: ['5', 6, 'B', 'A'],
      }],
    },
  },
  arr: ['Z', 'Y', 1, '2'],
};

const objB = {
  arr: ['Z', 'Y', 1, '2'],
  obj: {
    z: 'z',
    y: 'y',
    a: {
      obj: {
        x: 'x',
        w: 'w',
        b: 'b',
      },
      arr: ['3', 4, 'W', 'X', {
        obj: {
          k: 'k',
          i: 'i',
          c: 'c',
        },
        name: 'baz',
        value: 3,
        arr: ['5', 6, 'B', 'A'],
      }],
      name: 'bar',
      value: 2,
    },
  },
  name: 'foo',
  value: 1,
};

const objC = {
  arr: ['Z', 'Y', 1, '2'],
  obj: {
    z: 'z',
    y: 'y',
    a: {
      obj: {
        x: 'x',
        w: 'w',
        b: 'b',
      },
      arr: ['3', 4, 'W', 'X', {
        obj: {
          k: 'k',
          i: 'i',
          c: 'c',
        },
        name: 'baz',
        value: 3,
        arr: ['5', 6, 'B', 'A'],
      }],
      name: 'bar',
      value: 2,
    },
  },
  name: 'foo',
  value: 2,
};


console.log(
  'getJsonDataWithNormalizedKeyOrder(objA) ...',
  getJsonDataWithNormalizedKeyOrder(objA)
);
console.log(
  'getJsonDataWithNormalizedKeyOrder(objB) ...',
  getJsonDataWithNormalizedKeyOrder(objB)
);

console.log(
  'JSON.stringify(getJsonDataWithNormalizedKeyOrder(objA)) ...',
  JSON.stringify(getJsonDataWithNormalizedKeyOrder(objA))
);
console.log(
  'JSON.stringify(getJsonDataWithNormalizedKeyOrder(objB)) ...',
  JSON.stringify(getJsonDataWithNormalizedKeyOrder(objB))
);
console.log(
  'JSON.stringify(getJsonDataWithNormalizedKeyOrder(objC)) ...',
  JSON.stringify(getJsonDataWithNormalizedKeyOrder(objC))
);

console.log(
  'JSON.stringify(getJsonDataWithNormalizedKeyOrder(objA)).length ...',
  JSON.stringify(getJsonDataWithNormalizedKeyOrder(objA)).length
);
console.log(
  'JSON.stringify(getJsonDataWithNormalizedKeyOrder(objB)).length ...',
  JSON.stringify(getJsonDataWithNormalizedKeyOrder(objB)).length
);
console.log(
  'JSON.stringify(getJsonDataWithNormalizedKeyOrder(objC)).length ...',
  JSON.stringify(getJsonDataWithNormalizedKeyOrder(objC)).length
);

console.log(`
  JSON.stringify(
    getJsonDataWithNormalizedKeyOrder(objA)
  ) === JSON.stringify(
    getJsonDataWithNormalizedKeyOrder(objB)
  ) ?`,
  JSON.stringify(
    getJsonDataWithNormalizedKeyOrder(objA)
  ) === JSON.stringify(
    getJsonDataWithNormalizedKeyOrder(objB)
  )
);
console.log(`
  JSON.stringify(
    getJsonDataWithNormalizedKeyOrder(objA)
  ) === JSON.stringify(
    getJsonDataWithNormalizedKeyOrder(objC)
  ) ?`,
  JSON.stringify(
    getJsonDataWithNormalizedKeyOrder(objA)
  ) === JSON.stringify(
    getJsonDataWithNormalizedKeyOrder(objC)
  )
);

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

将上述内容应用于以更通用的方式解决 OP 原始问题的方法，然后可能看起来类似于下一行......

function defaultCompare(a, b) {
  return ((a < b) && -1) || ((a > b) && 1) || 0;
}
function comparePropertyNames(a, b) {
  return a.localeCompare
    ? a.localeCompare(b)
    : defaultCompare(a, b);
}

function getJsonDataWithNormalizedKeyOrder(data) {
  let value;
  if (Array.isArray(data)) {

    value = data.map(getJsonDataWithNormalizedKeyOrder);

  } else if (data && (typeof data === 'object')) {

    value = Object
      .getOwnPropertyNames(data)
      .sort(comparePropertyNames)
      .reduce((obj, key) => {
        obj[key] = getJsonDataWithNormalizedKeyOrder(data[key])
        return obj;
      }, {});

  } else {

    value = data;
  }
  return value;
}


const sampleList = [{
  name: 'John',
  value: 1,
}, {
  value: 1,
  name: 'John',
}, {
  name: 'Carla',
  value: 15,
}];

function hasDifferentValues(arr) {
  // stringified first item reference.
  const referenceItem = JSON.stringify(getJsonDataWithNormalizedKeyOrder(arr[0]));

  // run `some` from a sub-array which excludes the original array's first item.
  return arr.slice(1).some(item =>
    referenceItem !== JSON.stringify(getJsonDataWithNormalizedKeyOrder(item))
  );
}

console.log(
  'hasDifferentValues(sampleList) ?',
  hasDifferentValues(sampleList)
);

console.log(
  'hasDifferentValues(sampleList.slice(0,2)) ?',
  hasDifferentValues(sampleList.slice(0,2))
);
console.log(
  'hasDifferentValues(sampleList.slice(0,1)) ?',
  hasDifferentValues(sampleList.slice(0,1))
);

console.log(
  'hasDifferentValues(sampleList.slice(1)) ?',
  hasDifferentValues(sampleList.slice(1))
);

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

上一个：c# NaN Equals（）和 == 之间的比较差异

下一个：Dart 对象的默认 == 行为是什么？

对于符合 JSON 的对象文字数组，如何比较这些项的相等性？

For an array of JSON conform object literals, how does one compare the equality of such items?

评论

评论

评论

评论