我有一个对象被返回，我事先不知道它的结构。我唯一知道的是对象中应该有什么值。我的目标不是检查返回的对象是否与另一个对象具体匹配，而是检查返回的对象中是否存在特定的嵌套键值对。
以下是我期望返回的随机对象和我要检查的值。有没有已经写过的东西可以执行这种类型的检查？抱歉缺少代码，但我不确定从哪里开始。我考虑过可能会展平对象并进行检查，但由于未知的数组长度，这个想法没有实现。
// 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", 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"
}
我不知道这些是否与你相关。