检查javascript对象是否有嵌套的键值对

如何解决检查javascript对象是否有嵌套的键值对

我有一个对象被返回，我事先不知道它的结构。我唯一知道的是对象中应该有什么值。我的目标不是检查返回的对象是否与另一个特定匹配，而是检查返回的对象中是否存在特定的嵌套键值对。

以下是我期望返回的随机对象以及我想要检查的值。有没有已经写好的东西可以执行这种类型的检查？抱歉缺少代码，但我不确定从哪里真正开始。我想过可能会展平对象并进行检查，但由于未知的数组长度，这个想法没有成功。

// ob1 is the random object being returned. This will not be the same every time.
ob1 = {
    key_a: "val_a1",key_b: [
        "val_b1","val_b2","val_b3"
    ]
}

ob2a = {
    key_b: [
        "val_b2"
    ]
}

ob2b = {
    key_a: "val_a1",key_b: [
        "val_b3"
    ]
}

ob2c = {
    key_b: [
        "val_b2"
        "val_b3"
    ]
}

ob2d = {
    key_b: [
        "val_b1","val_doesnt exist"
    ]
}

ob2e = {
    key_b: "val_b1"
}

checkExists(ob1,ob2a) // true
checkExists(ob1,ob2b) // true
checkExists(ob1,ob2c) // true
checkExists(ob1,ob2d) // false
checkExists(ob1,ob2e) // false

解决方法

如果我在您的示例中正确理解您的话，ob1 是您想要比较其他 ob2a、...、ob2e 的对象。

这是我想出来的：

const checkExists = (ob1,ob2) => {
    // Filter for only matched keys between the two objects
    const matchedKeys = Object.keys(ob1).filter(key => {
        if(ob2[key] !== undefined) return key;
    });

    // No matched keys found so there are no nested key-value pairs 
    if(matchedKeys.length === 0) return false;
    else {
        let result = true;
        matchedKeys.forEach(key => {
            const ob1CurrentValue = ob1[key];
            const ob2CurrentValue = ob2[key];

            // Case: both values are arrays
            if(Array.isArray(ob1CurrentValue) && (Array.isArray(ob2CurrentValue))) {
                ob2CurrentValue.forEach(value => {
                    // If 1 value is not found result is false
                    if(!ob1CurrentValue.includes(value)) {
                        result = false;
                    }
                });
            // Case: both values are objects
            } else if(typeof ob1CurrentValue === 'object' && typeof ob2CurrentValue === 'object') {
                result = result && checkExists(ob1[key],ob2[key]);
            } else {
                result = ob1CurrentValue === ob2CurrentValue;
            }
        });

        return result;
    }
}

const ob1 = {key_a: "val_a1",key_b: ["val_b1","val_b2","val_b3"]};
const ob2a = {key_b: ["val_b2"]};
const ob2b = {key_a: "val_a1",key_b: ["val_b3"]};
const ob2c = {key_b: ["val_b2","val_b3"]};
const ob2d = {key_b: ["val_b1","val_doesnt exist"]};
const ob2e = {key_b: "val_b1"};
const ob2f = {key_c: "val_c1"};
const ob2g = {key_c: "val_c1",key_b: "val_b1"};
const ob2h = {key_c: "val_b1",key_b: "val_b1"};
const ob2i = {key_a: "val_a1","val_b3"],key_c: { key_c1: ["val_c1_1"],key_c2: ["val_c2_1"]}};
const ob2j = {key_c: {key_c1: ["val_c1_1"]}};
const ob2k = {key_a: "val_a11"};
const objl = {key_a: "val_a11",key_c: {"key_c1":["val_c1_1"]}};

console.log(checkExists(ob1,ob2a)); // true
console.log(checkExists(ob1,ob2b)); // true
console.log(checkExists(ob1,ob2c)); // true
console.log(checkExists(ob1,ob2d)); // false
console.log(checkExists(ob1,ob2e)); // false
console.log(checkExists(ob1,ob2f)); // false
console.log(checkExists(ob1,ob2g)); // false
console.log(checkExists(ob1,ob2h)); // false
console.log(checkExists(ob2i,ob2j)); // true
console.log(checkExists(ob2i,ob2k)); // false
console.log(checkExists(ob2i,objl)); // false

我所做的是首先在比较对象之间仅查找匹配的键，如果有匹配的键，我检查 ob1 是否包含每个键的 ob2 的所有值。

我还尝试涵盖更多情况，例如：

ob2f = {
    key_c: "val_c1"
}

ob2g = {
    key_c: "val_c1",key_b: "val_b1"
}

ob2h = {
    key_c: "val_b1",key_b: "val_b1"
}

我不知道这些是否与您相关。

,

    function checkIfExists(list1,list2) {
      let output = list2.filter(a=>!list1.some(b=>a==b))
      if(output.length==0) {
        return true;
      }
      return false
    }

   console.log(checkIfExists(ob1.key_b,ob2b.key_b))

您可以添加检查 ob2b.key_b 是否存在以及是否为数组。请注意，根据您的问题，它仅适用于数组。