我找到了这个(个人)方便的答案，它符合我的需求：https://stackoverflow.com/a/6713782/2678218
但是，由于我使用的是TypeScript，所以我可以使用Generics获得类似的东西：
private equals<T>(x: T, y: T) {
if (x === y) {
return true; // if both x and y are null or undefined and exactly the same
} else if (!(x instanceof Object) || !(y instanceof Object)) {
return false; // if they are not strictly equal, they both need to be Objects
} else if (x.constructor !== y.constructor) {
// they must have the exact same prototype chain, the closest we can do is
// test their constructor.
return false;
} else {
for (const p in x) {
if (!x.hasOwnProperty(p)) {
continue; // other properties were tested using x.constructor === y.constructor
}
if (!y.hasOwnProperty(p)) {
return false; // allows to compare x[ p ] and y[ p ] when set to undefined
}
if (x[p] === y[p]) {
continue; // if they have the same strict value or identity then they are equal
}
if (typeof (x[p]) !== 'object') {
return false; // Numbers, Strings, Functions, Booleans must be strictly equal
}
if (!this.equals(x[p], y[p])) {
return false;
}
}
for (const p in y) {
if (y.hasOwnProperty(p) && !x.hasOwnProperty(p)) {
return false;
}
}
return true;
}
}
我确信，由于我们在这里使用<T>，我们可以重构代码。有一件事是可以肯定的，那就是删除一些不再需要的if语句。但我不确定该去掉哪一个，也不确定是否会有更优化的代码。所以我把问题留在这里，让大家投票选出最好的答案。
在这种情况下，我所说的两个对象的相等实际上是指两个相同类型的对象的每个属性的值相等。
@Lostfields提到有人可以为类型T传递any，但这并不是什么大问题，因为使用any是在告诉编译器不要键入check。如果这在运行时导致不希望的行为，我会将处理此问题的责任放在any中传递的代码上，而不是equals()中的代码上。类型系统的一个用途实际上是消除一些不必要的运行时检查，但需要注意的是，您仍然需要对从不受信任的源传入的任何数据进行清理。你是否正在构建一个库，供那些甚至可能不使用TypeScript的开发人员使用？然后不要放松任何运行时检查。您构建的代码是内部使用的，还是由其他依赖您打字的TypeScript开发人员使用的？然后尽一切可能消除不必要的检查。
也就是说，我不认为你可以删除该实现中的许多检查。检查的每个条件在运行时可能是true或false，即使知道TypeScript已经决定x和y属于同一类型。(在下面的内容中，我将把equals()视为一个独立的函数，而不是一个方法。添加this或任何您认为合适的对象名称)
让我们检查每一个：
-
(x === y)：对于equals(x,x)为True，对于equals(x, Object.assign({},x))为false。这个必须留下来。 -
((!(x instanceof Object) || !(y instanceof Object)):您可能会决定仅用(!(x instanceof Object))替换此类型，因为在实践中，TypeScript中的类型要么是Object，要么不是，因此x instanceof Object应该与y instanceof Object相同。不过，有些人可能会执行equals(0, new Number(0))，它通过TypeScript中的类型检查。这取决于你是否关心防范。 -
(x.constructor !== y.constructor)：对于两个结构相同的类，例如class A{}; class B{}; equals(new A(), new B())，为False。如果您不担心结构相同但不同的类，可以取消此检查。 -
(!x.hasOwnProperty(p))：此检查与TypeScript无关；它必须留下来。
对于下一种情况，请考虑
interface Foo { foo?: string, bar: number, baz?: boolean };
const x: Foo = { foo: 'hello', bar: 12 };
const y: Foo = { bar: 12, baz: false };
equals(x, y);
(!y.hasOwnProperty(p))和(y.hasOwnProperty(p) && !x.hasOwnProperty(p))：对于Foo的实例，或者具有可选属性的任何类型，它们可能是true或false。或者没有可选属性的类型的任何子类型，因为TypeScript中允许额外的属性。(x[p] === y[p])、(typeof (x[p]) !== 'object')、(!equals(x[p], y[p]))：由于与上述相同的原因，这些可以是true或false，这可以通过传入具有上述类型的单个属性的类型来看出。也就是说，如果equals(x,y)需要运行时检查，那么equals({foo: x},{foo: y})将需要相同的运行时检查。
所以，这取决于你。请放心，不要理会实施。毕竟，额外的运行时检查不会对造成任何伤害。如果你认为自己不需要支票，可以随意删除一些支票；再说一遍，你是唯一一个知道equals()的用户会有多疯狂的人。例如，你会怎么做：
interface Ouroboros {
prop: Ouroboros;
}
let x = {} as Ouroboros;
x.prop = x;
let y = {} as Ouroboros;
y.prop = y;
console.log(equals(x,y))
你关心循环引用吗？如果没有，不要担心。如果是这样，那么你需要加强你的平等检查来处理它
希望能有所帮助；祝你好运