你可以使用_。isEqual(obj1, obj2)来自underscore.js库。

这里有一个例子:

var stooge = {name: 'moe', luckyNumbers: [13, 27, 34]};
var clone  = {name: 'moe', luckyNumbers: [13, 27, 34]};
stooge == clone;
=> false
_.isEqual(stooge, clone);
=> true

在这里查看官方文档:http://underscorejs.org/#isEqual

我需要模拟jQuery POST请求，因此对我来说重要的是两个对象具有相同的属性集(任何一个对象中都不缺少属性)，并且每个属性值都是“相等的”(根据这个定义)。我不关心对象是否有不匹配的方法。

这是我将使用的，它应该足以满足我的特定要求:

function PostRequest() {
    for (var i = 0; i < arguments.length; i += 2) {
        this[arguments[i]] = arguments[i+1];
    }

    var compare = function(u, v) {
        if (typeof(u) != typeof(v)) {
            return false;
        }

        var allkeys = {};
        for (var i in u) {
            allkeys[i] = 1;
        }
        for (var i in v) {
            allkeys[i] = 1;
        }
        for (var i in allkeys) {
            if (u.hasOwnProperty(i) != v.hasOwnProperty(i)) {
                if ((u.hasOwnProperty(i) && typeof(u[i]) == 'function') ||
                    (v.hasOwnProperty(i) && typeof(v[i]) == 'function')) {
                    continue;
                } else {
                    return false;
                }
            }
            if (typeof(u[i]) != typeof(v[i])) {
                return false;
            }
            if (typeof(u[i]) == 'object') {
                if (!compare(u[i], v[i])) {
                    return false;
                }
            } else {
                if (u[i] !== v[i]) {
                    return false;
                }
            }
        }

        return true;
    };

    this.equals = function(o) {
        return compare(this, o);
    };

    return this;
}

像这样使用:

foo = new PostRequest('text', 'hello', 'html', '<p>hello</p>');
foo.equals({ html: '<p>hello</p>', text: 'hello' });

这里有很多好的想法!这是我对深度相等的理解。我把它发布在github上，并围绕它写了一些测试。很难涵盖所有可能的情况，有时也没有必要这样做。

我介绍了NaN !== NaN以及循环依赖关系。

https://github.com/ryancat/simple-deep-equal/blob/master/index.js

如果两个对象的所有属性都具有相同的值，并且所有嵌套对象和数组都递归地具有相同的值，那么将它们视为相等是很有用的。我也认为以下两个对象是相等的:

var a = {p1: 1};
var b = {p1: 1, p2: undefined};

类似地，数组可以有“缺失”元素和未定义的元素。我也会同样对待它们:

var c = [1, 2];
var d = [1, 2, undefined];

函数:实现等式定义的函数:

function isEqual(a, b) {
    if (a === b) {
        return true;
    }

    if (generalType(a) != generalType(b)) {
        return false;
    }

    if (a == b) {
        return true;
    }

    if (typeof a != 'object') {
        return false;
    }

    // null != {}
    if (a instanceof Object != b instanceof Object) {
        return false;
    }

    if (a instanceof Date || b instanceof Date) {
        if (a instanceof Date != b instanceof Date ||
            a.getTime() != b.getTime()) {
            return false;
        }
    }

    var allKeys = [].concat(keys(a), keys(b));
    uniqueArray(allKeys);

    for (var i = 0; i < allKeys.length; i++) {
        var prop = allKeys[i];
        if (!isEqual(a[prop], b[prop])) {
            return false;
        }
    }
    return true;
}

源代码(包括辅助函数，generalType和uniqueArray): 这里是单元测试和测试运行器。

我写了一个运行在Node.js和浏览器上的小库，叫做compare.js。它提供了常见的比较运算符，例如==，!=，>，>=，<，<=和所有JavaScript数据类型的标识符。

例如，你可以用

cmp.eq(obj1, obj2);

这将检查是否相等(使用深度相等的方法)。否则，如果你这样做

cmp.id(obj1, obj2);

它将通过引用进行比较，从而检查标识。 您还可以在对象上使用<和>，它们表示子集和超集。

Compare.js被近700个单元测试覆盖，因此它应该不会有太多的bug;-)。

你可以在https://github.com/goloroden/compare.js上免费找到它，它是MIT许可下的开源软件。

我也遇到了同样的问题，并决定自己编写解决方案。但是因为我也想比较数组和对象，反之亦然，所以我设计了一个通用的解决方案。我决定将函数添加到原型中，但是可以很容易地将它们重写为独立的函数。代码如下:

Array.prototype.equals = Object.prototype.equals = function(b) {
    var ar = JSON.parse(JSON.stringify(b));
    var err = false;
    for(var key in this) {
        if(this.hasOwnProperty(key)) {
            var found = ar.find(this[key]);
            if(found > -1) {
                if(Object.prototype.toString.call(ar) === "[object Object]") {
                    delete ar[Object.keys(ar)[found]];
                }
                else {
                    ar.splice(found, 1);
                }
            }
            else {
                err = true;
                break;
            }
        }
    };
    if(Object.keys(ar).length > 0 || err) {
        return false;
    }
    return true;
}

Array.prototype.find = Object.prototype.find = function(v) {
    var f = -1;
    for(var i in this) {
        if(this.hasOwnProperty(i)) {
            if(Object.prototype.toString.call(this[i]) === "[object Array]" || Object.prototype.toString.call(this[i]) === "[object Object]") {
                if(this[i].equals(v)) {
                    f = (typeof(i) == "number") ? i : Object.keys(this).indexOf(i);
                }
            }
            else if(this[i] === v) {
                f = (typeof(i) == "number") ? i : Object.keys(this).indexOf(i);
            }
        }
    }
    return f;
}

本算法分为两部分;equals函数本身和一个在数组/对象中查找属性数值索引的函数。find函数只需要，因为indexof只查找数字和字符串，不查找对象。

我们可以这样称呼它:

({a: 1, b: "h"}).equals({a: 1, b: "h"});

函数返回true或false，在本例中为true。 算法als允许在非常复杂的对象之间进行比较:

({a: 1, b: "hello", c: ["w", "o", "r", "l", "d", {answer1: "should be", answer2: true}]}).equals({b: "hello", a: 1, c: ["w", "d", "o", "r", {answer1: "should be", answer2: true}, "l"]})

上面的例子将返回true，即使属性的顺序不同。需要注意的一个小细节:这段代码还检查两个变量的相同类型，因此“3”与3不同。