我需要模拟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' });

我知道这有点老了，但我想添加一个解决方案，我想出了这个问题。 我有一个对象，我想知道它的数据什么时候改变。类似于Object。我所做的是:

function checkObjects(obj,obj2){
   var values = [];
   var keys = [];
   keys = Object.keys(obj);
   keys.forEach(function(key){
      values.push(key);
   });
   var values2 = [];
   var keys2 = [];
   keys2 = Object.keys(obj2);
   keys2.forEach(function(key){
      values2.push(key);
   });
   return (values == values2 && keys == keys2)
}

这里可以复制并创建另一组数组来比较值和键。 这很简单，因为它们现在是数组，如果对象大小不同将返回false。

这是对以上所有内容的补充，而不是替代。如果需要快速浅比较对象，而不需要检查额外的递归情况。这是一个镜头。

这比较:1)自己的属性数量相等，2)键名相等，3)如果bCompareValues == true，对应的属性值及其类型相等(三重相等)

var shallowCompareObjects = function(o1, o2, bCompareValues) {
    var s, 
        n1 = 0,
        n2 = 0,
        b  = true;

    for (s in o1) { n1 ++; }
    for (s in o2) { 
        if (!o1.hasOwnProperty(s)) {
            b = false;
            break;
        }
        if (bCompareValues && o1[s] !== o2[s]) {
            b = false;
            break;
        }
        n2 ++;
    }
    return b && n1 == n2;
}

简短的回答

简单的答案是:不，没有一般的方法来确定一个对象等于另一个你所指的意义。例外情况是当您严格地认为一个对象是无类型的。

长话短说

这个概念是一个Equals方法，它比较一个对象的两个不同实例，以指示它们在值级别上是否相等。但是，定义Equals方法应该如何实现取决于具体的类型。对具有基本值的属性进行迭代比较可能还不够:对象可能包含与相等无关的属性。例如,

 function MyClass(a, b)
 {
     var c;
     this.getCLazy = function() {
         if (c === undefined) c = a * b // imagine * is really expensive
         return c;
     }
  }

在上面的例子中，c对于确定MyClass的任何两个实例是否相等并不重要，只有a和b是重要的。在某些情况下，c可能在不同实例之间有所不同，但在比较中并不显著。

注意，当成员本身也可能是某个类型的实例，并且每个实例都需要有确定相等的方法时，这个问题就会出现。

更复杂的是，在JavaScript中，数据和方法之间的区别是模糊的。

一个对象可以引用一个作为事件处理程序调用的方法，这可能不被认为是其“值状态”的一部分。然而，另一个对象很可能被分配一个执行重要计算的函数，从而使这个实例与其他实例不同，仅仅因为它引用了不同的函数。

如果一个对象的现有原型方法被另一个函数覆盖，该怎么办?它还能被认为与另一个相同的实例相等吗?这个问题只能在每种类型的具体情况下回答。

如前所述，异常将是一个严格的无类型对象。在这种情况下，唯一明智的选择是对每个成员进行迭代和递归比较。即使这样，人们也要问一个函数的“值”是什么?

如果你的问题是检查两个对象是否相等，那么这个函数可能会有用

function equals(a, b) {
const aKeys = Object.keys(a)
const bKeys = Object.keys(b)
if(aKeys.length != bKeys.length) {
    return false
}
for(let i = 0;i < aKeys.length;i++) {
    if(aKeys[i] != bKeys[i]) {
        return false
    } 
}
for(let i = 0;i < aKeys.length;i++) {
    if(a[aKeys[i]] != b[bKeys[i]]) {
        return false
    }
}
return true
}

first we check if the length of the list of keys of these objects is the same, if not we return false to check if two objects are equal they must have the same keys(=names) and the same values of the keys, so we get all the keys of objA, and objB and then we check if they are equal once we find that tow keys are not equal then we return false and then when all the keys are equal then we loop through one of the keys of one of the objects and then we check if they are equal once they are not we return false and after the two loops finished this means they are equal and we return true NOTE: this function works with only objects with no functions

这个问题已经有30多个答案了。我将总结并解释它们(用“我父亲”的比喻)，并添加我建议的解决方案。

你有4+1类解

---

1)使用不完整的简单语句

如果你赶时间，那么99%的正确性都可以。

例如，Pratik Bhalodiya建议的JSON.stringify()或JSON。encode，或. tostring()，或其他方法将对象转换为String，然后逐个字符使用===比较两个String。

然而，缺点是在String中没有Object的全局标准唯一表示。例如:{a: 5, b: 8}和{b: 8和a: 5}是相等的。

优点:快，快。 缺点:希望有效!如果环境/浏览器/引擎记住了对象的顺序(例如Chrome/V8)，并且键的顺序不同(感谢Eksapsy)，它将无法工作。所以，完全不能保证。在大型对象中，性能也不会很好。

我的父亲类比

当我在谈论我的父亲时，“我高大英俊的父亲”和“我高大英俊的父亲”是同一个人!但这两个弦是不一样的。

请注意，在英语语法中，形容词的顺序其实是正确的(标准的方式)，它应该是“英俊的高个子男人”，但如果你盲目地认为iOS 8 Safari的Javascript引擎也遵循同样的语法，你就是在拿自己的能力冒险!# WelcomeToJavascriptNonStandards

---

2)自己DIY编写递归函数

如果你正在学习，这很好。

例子是atmin的解。

最大的缺点是你肯定会错过一些边缘情况。您考虑过对象值中的自引用吗?你考虑过NaN吗?您是否考虑过具有相同ownProperties但不同原型父对象的两个对象?

我只鼓励人们在进行实践并且代码不会投入生产的情况下这样做。这是唯一一种重新发明轮子有正当理由的情况。

优点:学习机会。 缺点:不可靠。需要时间和精力。

我的父亲类比

这就像假设我爸爸的名字是“约翰·史密斯”，他的生日是“1/1/1970”，那么任何一个名字是“约翰·史密斯”，出生在“1/1/1970”的人就是我的父亲。

通常情况下是这样，但如果有两个“约翰·史密斯”在那一天出生呢?如果你认为你会考虑他们的身高，那么这就提高了准确性，但仍然不是一个完美的比较。

2.1你的范围有限DIY比较器

与其疯狂地递归检查所有属性，不如考虑只检查“有限”数量的属性。例如，如果对象是Users，您可以比较它们的emailAddress字段。

它仍然不是一个完美的解决方案，但比解决方案#2的好处是:

它是可预测的，而且不太可能崩溃。 您正在推动平等的“定义”，而不是依赖于对象的原始形式和形状及其原型和嵌套属性。

---

3)使用功能相同的图书馆版本

如果您需要生产级别的质量，并且您不能更改系统的设计，则很好。

例如_。等于lodash，已经在coolaj86的回答中，或者在Tony Harvey的回答中提到的Angular的回答中，或者在Node的Rafael Xavier的回答中。

优点:其他人都这么做。 缺点:外部依赖，这可能会花费你额外的内存/CPU/安全问题，甚至一点点。此外，仍然可以错过一些边缘情况(例如，是否两个对象具有相同的ownProperties但不同的原型父应该被认为是相同的。)最后，你可能无意中解决了一个潜在的设计问题;只是说!

我的父亲类比

这就像付钱给中介机构，根据他的电话、姓名、地址等找到我的生父。

这会花更多的钱，而且可能比我做背景调查更准确，但不能涵盖边缘情况，比如我父亲是移民/庇护者，他的生日是未知的!

---

4)在对象中使用标识符

如果你仍然可以改变系统(你正在处理的对象)的设计，并且你希望你的代码能够持久，那就太好了。

它并不适用于所有情况，而且性能可能不太好。然而，这是一个非常可靠的解决方案，如果你能做到的话。

解决方案是，系统中的每个对象都有一个唯一的标识符以及所有其他属性。标识符的唯一性将在生成时得到保证。在比较两个对象时，您将使用这个ID(也称为UUID/GUID—全局/通用唯一标识符)。即，当且仅当这些id相等时，它们相等。

id可以是简单的自动增量数字，也可以是通过库生成的字符串(建议)或一段代码。所有你需要做的是确保它总是唯一的，在auto_incremental的情况下，它可以是内置的，或者在UUID的情况下，可以检查是否所有现有的值(例如MySQL的unique列属性)或简单地(如果来自库)依赖于给出极低的冲突可能性。

注意，您还需要始终将ID存储在对象中(以保证其唯一性)，并且实时计算它可能不是最好的方法。

优点:可靠，高效，不脏，现代。 缺点:需要额外的空间。可能需要重新设计一下系统。

我的父亲类比

我父亲的社保号是911-345-9283，所以有这个社保号的人就是我父亲，任何自称是我父亲的人也一定有这个社保号。

---

结论

就准确性和可靠性而言，我个人更喜欢解决方案#4 (ID)。如果不可能，我会选择2.1，因为它具有可预测性，然后是3。如果两者都不可能，选择第二条，最后是第一条。