检查javascript对象是否具有嵌套的键值对[重复]

Question

我返回了一个我事先不知道其结构的对象。我唯一知道的是对象中应该包含哪些值。我的目标不是检查返回的对象是否与另一个对象特别匹配，而是检查返回的对象中是否存在特定的嵌套键值对。

以下是我期望返回的随机对象以及我想要检查的值。是否已经编写了执行此类检查的任何内容？抱歉缺少代码，但我不确定从哪里开始。我考虑过将对象展平并进行检查，但由于数组长度未知，这个想法没有成功。

// 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

Answer 1

    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 是否存在以及是否为数组。请注意，根据您的问题，它仅适用于数组。

Answer 2

如果我在您的示例中正确理解了您，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", key_b: ["val_b1", "val_b2", "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"
}

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