如何检查一个 JavaScript 对象中的值是否存在于另一个 JavaScript 对象中

How to check if values in one JavaScript object are present in another one?

本文关键字：JavaScript 对象 另一个 是否 存在 一个 何检查 检查      更新时间：2023-09-26

我正在尝试比较json_str1和json_str2，在这里它应该返回true，因为json_str1中的所有元素都存在于json_str2中。

现在我正在像这样做很长的路

json_str1 = '{"0":"a","1":"b","2":"c"}';
json_str2 = '{"0":"c","1":"b","2":"a"}';
json_obj1 = $.parseJSON(json_str1);
json_obj2 = $.parseJSON(json_str2);
arr1 = $.map(json_obj1, function(el) { return el });
arr2 = $.map(json_obj2, function(el) { return el });
if($(arr1).not(arr2).length === 0 && $(arr2).not(arr1).length === 0)
    alert("equal");
else
    alert("not equal");

如何在不将对象转换为数组的情况下使其简短而简单？

https://jsfiddle.net/kq9gtdr0/

使用以下代码：

Object.keys(json_obj1) . every(k1 => 
  Object.keys(json_obj2) . some(k2 =>
    json_obj1[k1] === json_obj2[k2]
  )
);

英文版：

json_obj1中的每个键k1都满足以下条件：json_obj2中的某些键k2满足具有键k1的json_obj1值等于具有键k2的json_obj2值的条件。

或者用更会话的英语：

第一个对象中的每个值都与第二个对象中的某个值匹配。

使用 lodash

var _ = require('lodash');
function compareValues(jstr1, jstr2) {
  return _.isEqual(_.valuesIn(JSON.parse(jstr1)).sort(), _.valuesIn(JSON.parse(jstr2)).sort());
}
json_str1 = '{"0":"a","1":"b","2":"c"}';
json_str2 = '{"0":"c","1":"b","2":"a"}';
console.log(compareValues(json_str1, json_str2));

有简短而简单准确的方法。

您可以使用名为 Lodash 的第三方但非常流行的实用程序库。可以检查相等性的链接函数。

  1. 首先将两个 JSON 解析为对象
  2. 然后使用 _.values（） 将每个键的所有键的值提取到单独的数组中
  3. 找出两个数组的差异。如果它是一个空数组，则它们都是相等的。

您可以将所有步骤链接到一个语句中，如下所示：

_.isEmpty(_.difference(_.values(json_obj1), _.values(json_obj2)))

示例：https://jsfiddle.net/kq9gtdr0/4/

欲了解更多信息：

https://lodash.com/docs#values

https://lodash.com/docs#difference

https://lodash.com/docs#isEmpty

您可以从 CDN（https://cdn.jsdelivr.net/lodash/4.5.1/lodash.min.js） 包含库，也可以下载并将其用作普通脚本。Lodash提供了许多有用的实用程序函数，使JS编程变得更加容易。你最好试试。

如果您更喜欢使用库，则可以使用下划线isMatch

_.isMatch(object, properties)

告诉您属性中的键和值是否包含在 对象。

通过@user663031扩展令人敬畏的答案，如果您需要进行深度比较，以下是有效的代码：

export function objectOneInsideObjectTwo(jsonObj1: any, jsonObj2: any): boolean {
  return Object.keys(jsonObj1).every((k1) => {
    if (parseType(jsonObj1[k1]) === 'dict') {
      return objectOneInsideObjectTwo(jsonObj1[k1], jsonObj2[k1]);
    }
    if (parseType(jsonObj1[k1]) === 'array') {
      const results: boolean[] = [];
      jsonObj1[k1].forEach((o: any, i: number) => {
        if (parseType(o) === 'dict') {
          results.push(objectOneInsideObjectTwo(o, jsonObj2[k1][i]));
        } else {
          results.push(o === jsonObj2[k1][i]);
        }
      });
      return results.every((r) => r);
    }
    return Object.keys(jsonObj2).some((k2) => jsonObj1[k1] === jsonObj2[k2]);
  });
}
export function parseType<T>(v: T): string {
  if (v === null || v === undefined) {
    return 'null';
  }
  if (typeof v === 'object') {
    if (v instanceof Array) {
      return 'array';
    }
    if (v instanceof Date) {
      return 'date';
    }
    return 'dict';
  }
  return typeof v;
}
你可以

试试这个

var json_str1 = {"0":"a","1":"b","2":"c"};
var json_str2 = {"0":"c","1":"b","2":"a"};
var flag =  1;
if(Object.keys(json_str1).length == Object.keys(json_str2).length){
    Object.keys(json_str1).forEach(function(x){
        if(!json_str2.hasOwnProperty(x) || json_str2[x] != json_str1[x]){
            flag = 0;
            return;
        }                      
    });
}
if(flag)
    alert('equal');
else
    alert('Not Equal');

如果您想找出两个对象是否具有相同的键，那么如果不至少将两个对象的键转换为具有Object.keys的数组或循环遍历两个对象，就无法做到这一点！

原因很简单：很明显，您必须比较两个对象的键数，唯一的方法是遍历所有属性或Object.keys。

所以我认为最短的方法是：

json_obj1 = JSON.parse('{"0":"a","1":"b","2":"c"}');
json_obj2 = JSON.parse('{"0":"c","1":"b","2":"a"}');
keys_1 = Object.keys(json_obj1);
keys_2 = Object.keys(json_obj2);
if(keys_1.length === keys_2.length && keys_1.every(key => keys_2.indexOf(key) >= 0)) {
    alert('equal')
} else {
    alert('not equal')
}

如果您只想检查 json1 中的所有键是否存在于 json2 中，您可以执行以下操作：

json_obj1 = JSON.parse('{"0":"a","1":"b","2":"c"}');
json_obj2 = JSON.parse('{"0":"c","1":"b","2":"a"}');
if(Object.keys(json_obj1).every(key => key in json_obj2)) {
  alert('equal');
} else {
  alert('not equal');
}

在您的问题和评论中，您表示您只是想验证"json_str1中的所有元素都存在于json_str2中"。您的示例代码不仅这样做，它还通过测试第一个对象中的所有键（不是值）是否都在第二个对象中以及第二个对象中的所有键都在第一个对象中来检查键的完全相等性。 通过查看您的代码，我假设当您说"元素"时，您指的是键。

除此之外，这可能会有所帮助：

// Your first few lines of code
json_str1 = '{"0":"a","1":"b","2":"c"}';
json_str2 = '{"0":"c","1":"b","2":"a"}';
json_obj1 = $.parseJSON(json_str1);
json_obj2 = $.parseJSON(json_str2);
// My new code
var values1 = Object.keys(json_obj1).map(key => json_obj1[key]);
var values2 = Object.keys(json_obj2).map(key => json_obj2[key]);
// Check if every key in the first object is in the second object.
values1.every(k1 => values2.indexOf(k1) >= 0);
// OR
// Check for equality of keys by checking both directions.
values1.every(k1 => values2.indexOf(k1) >= 0) && values2.every(k2 => values1.indexOf(k2) >= 0);

这是 2 行获取密钥，一行要检查。 您只需要这两项检查之一。

相关文章：