对象比较：检查一个对象是否包含整个其他对象

Question

我有两个对象。它们的结构看起来有点像这样：

{
 education: ["school", "institute"],
 courses: ["HTML", "JS", "CSS"],
 Computer: {
        "OS":"WXP",
        "WS":"NotePad"
         }
 }

第二个：

{
 education: ["school", "university", "institute", "collage"],
 courses: ["HTML", "CSS", "JS", "Managing", "Directing"],
 Computer: {
        "OS":"WXP",
        "WS":"NotePad",
        "AV":"Avast"
         },
 something: function(){...},
 other: "thing"

}

您可能已经注意到，第二个对象包含整个第一个对象，以及第一个对象没有的一些项目。
我需要比较这两个对象，如果第二个对象包含第一个对象的每个项目，我需要得到答案（true-false）。
true - 如果第一个对象的所有项目也在第二个
false - 如果第一个对象的至少一个项目不在第二个中，例如：如果第二个对象没有“css”课程。

（第一个是要求，第二个是这个人有什么。我需要检查这个人是否具备所有要求）

可以是普通的 JS、jQuery 等。我不想为此使用服务器端语言。

有没有办法做到这一点？

谢谢！

Answer 1

只需递归检查：

function isContainedIn(a, b) {
    if (typeof a != typeof b)
        return false;
    if (Array.isArray(a) && Array.isArray(b)) {
        // assuming same order at least
        for (var i=0, j=0, la=a.length, lb=b.length; i<la && j<lb;j++)
            if (isContainedIn(a[i], b[j]))
                i++;
        return i==la;
    } else if (Object(a) === a) {
        for (var p in a)
            if (!(p in b && isContainedIn(a[p], b[p])))
                return false;
        return true;
    } else
        return a === b;
}

> isContainedIn(requirements, person)
true

对于更类似于集合逻辑的数组方法，顺序无关紧要，添加类似

        a.sort();
        b = b.slice().sort()

（假设可排序的内容）在数组比较循环之前或用效率很低的替换它

        return a.every(function(ael) {
            return b.some(function(bel) {
                return isContainedIn(ael, bel);
            });
        });

Answer 2

JavaScript（在 ES5 中）有两种复合原生类型（我假设您的代码中没有任何自定义集合，如果有的话 - 我假设它们支持“旧”迭代协议（具有 .length）

这是一个带注释的解决方案草图。我没有运行这个——它是为了让你了解如何实现这个算法。请注意，这会进入反向引用 (var a = {}; a.a =a}) 的无限循环。

function sub(big,small){
    if(typeof big === "function") return small === big; // function reference equality.
    if(big.length){ // iterable, for example array, nodelist etc. (even string!)
        if(small.length > big.length) return false; // small is bigger!
        for(var i = 0; i < small.length; i++ ){
            if(!sub(big[i],small[i])){ // doesn't have a property
                return false;
            }
        }
        return true; // all properties are subproperties recursively
    }
    if(typeof big === "object" && big !== null){
        // I assume null is not a subset of an object, you may change this, it's conceptual
        if(typeof small !== "object" || small === null) return false; 
        for(var key in small){
            // I consider the prototype a part of the object, you may filter this with a 
            // hasOwnProperty check here.
            if(!sub(big[key],small[key])){ // doesn't have a property
                 return false;
            }
            return true;
        }
    }
    return big === small; // primitive value type equality
                          // , or ES7 value type equality, future compat ftw :P
}

Answer 3

编辑：没有注意到merge 更改了第一个参数...更改了代码，但它仍然会导致 obj2 更改。您可以添加 _.cloneDeep(obj2) 来解决这个问题，但到那时我的解决方案似乎并不那么优雅。也用cloneDeep 更新了演示。

Edit2：由于JSON.stringify 要求您比较的对象中对象属性的顺序相同，因此您可以改用Object comparison in JavaScript 之类的东西。但是，在演示中您可以看到它有效，所以我想说，对于您的情况，使用 _.merge 和 JSON.stringify 很有可能是可靠的。

使用lo-dash，您可以使用_.merge 并检查结果是否与较大的对象相同。

function(obj1, obj2) {
    var obj3 =_.merge(_.cloneDeep(obj2), obj1);
    return JSON.stringify(obj3) === JSON.stringify(obj1);
}

demo

当然，另一种选择是使用 vanilla JS 遍历整个对象。

Answer 4

//当对象顺序不同时

function isContainedIn(a, b) {
    if (typeof a != typeof b)
        return false;
    if (Array.isArray(a) && Array.isArray(b)) {
        if(a.length == 1) {
            var j=0;
            while (j < b.length) {
                if ((isContainedIn( a[0], b[j]))) {
                    return true;
                }
                j++;
            }
            return false;
        } else {
            var k=0;
            while (k < a.length) {
                if (!(isContainedIn([a[k]], b))) {
                    return false;
                }
                k++;
            }
            return true;
        }
    } else if (Object(a) === a) {
        for (var p in a)
            if (!(p in b && isContainedIn(a[p], b[p])))
                return false;
        return true;
    } else
        return a === b;
};


isContainedIn(requirements, person)
true

Answer 5

除了本杰明的回答 - 你可以测试一下：

const sub = (big, small) => {
    if (typeof big === 'function' || typeof small === 'string') return small === big; // function or string reference equality
    if (big && big.length) { // iterable, for example array, nodelist etc. (even string!)
        if (small.length > big.length) return false; // small is bigger!
        for (let i = 0; i < small.length; i++)
            if (!sub(big[i], small[i])) // doesn't have a property
                return false;
        return true; // all properties are subproperties recursively
    }
    if (typeof big === 'object' && big !== null) {
        // I assume null is not a subset of an object, you may change this, it's conceptual
        if (typeof small !== 'object' || small === null) return false;
        // console.log(Object.keys(small));
        for (const key of Object.keys(small)) {
            // I consider the prototype a part of the object, you may filter this with a
            // hasOwnProperty check here.
            if (sub(big[key], small[key]) === false) // doesn't have a property
                return false;
            continue;
        }
        return true;
    }
    return big === small; // primitive value type equality
};

甚至使用更清洁的解决方案： https://github.com/blackflux/object-deep-contain