在对象中(没有方法)，我们需要检查嵌套的对象，数组和基本类型。对象可以有其他对象和数组(数组也可以包括其他对象和数组)，所以我们可以使用如下所示的递归函数:arrayEquals检查数组是否相等，equals检查对象是否相等:

function arrayEquals(a, b) {
    if (a.length != b.length) {
        return false;
    }
    for (let i = 0; i < a.length; i++) {
        if (a[i].constructor !== b[i].constructor) {
            return false;
        }

        if (a[i] instanceof Array && b[i] instanceof Array) {
            if (!arrayEquals(a, b)) {
                return false;
            }
        } else if (a[i] instanceof Object && b[i] instanceof Object) {
            if (!equals(a[i], b[i])) {
                return false;
            }
        } else if (a[i] !== b[i]) {
            return false;
        }
    }
    return true;
}

function equals(a, b) {
    for (let el in a) {
        if (b.hasOwnProperty(el)) {
            if (a[el].constructor !== b[el].constructor) {
                return false;
            }

            if (a[el] instanceof Array && b[el] instanceof Array) {
                if (!arrayEquals(a[el], b[el])) {
                    return false;
                }
            } else if (a[el] instanceof Object && b[el] instanceof Object) {
                if (!equals(a[el], b[el])) {
                    return false;
                }
            } else if (a[el] !== b[el]) {
                return false;
            }
        } else {
            return false;
        }
    }
    return true;
}

假设你有两个对象:

let a = {
    a: 1,
    b: { c: 1, d: "test" },
    c: 3,
    d: [{ a: [1, 2], e: 2 }, "test", { c: 3, q: 5 }],
};

let b = {
    a: 1,
    b: { c: 1, d: "test" },
    c: 3,
    d: [{ a: [1, 2], e: 2 }, "test", { c: 3, q: 5 }],
};

在这里使用上面的equals函数，你可以很容易地比较这两个对象，像这样:

if(equals(a, b)) {
    // do whatever you want
}

简短的回答

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

长话短说

这个概念是一个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中，数据和方法之间的区别是模糊的。

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

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

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

如何确定部分对象(partial <T>)等于typescript中的原始对象(T)。

function compareTwoObjects<T>(original: T, partial: Partial<T>): boolean {
  return !Object.keys(partial).some((key) => partial[key] !== original[key]);
}

附注:最初我打算提出一个有答案的新问题。但这样的问题已经存在，并被标记为重复题。

你可以使用_。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

判断两个对象是否相似的一个快速“破解”方法是使用它们的toString()方法。如果您正在检查对象A和B，请确保A和B具有有意义的toString()方法，并检查它们返回的字符串是否相同。

这不是灵丹妙药，但有时在正确的情况下是有用的。

对于那些使用Node的人来说，在本地util库中有一个叫做isDeepStrictEqual的方便方法可以实现这一点。

const util = require('util');

const obj1 = {
  foo: "bar",
  baz: [1, 2]
};

const obj2 = {
  foo: "bar",
  baz: [1, 2]
};


obj1 == obj2 // false
util.isDeepStrictEqual(obj1, obj2) // true

https://nodejs.org/api/util.html#util_util_isdeepstrictequal_val1_val2