javascript - 为什么两个相同的对象不相等？

Question

似乎下面的代码应该返回一个 true，但它返回 false。

var a = {};
var b = {};

console.log(a==b); //returns false
console.log(a===b); //returns false

这有什么意义？

Answer 1

==常规 ( ) 和严格 ( ) 相等之间的唯一区别===是严格相等运算符禁用类型转换。由于您已经在比较相同类型的两个变量，因此您使用的相等运算符类型无关紧要。

无论您是使用常规相等还是严格相等，对象比较仅true 在您比较相同的确切对象时才评估。

也就是说，给定var a = {}, b = a, c = {};, a == a, a == b, 但是a != c。

两个不同的对象（即使它们都具有零或完全相同的属性）永远不会相等比较。如果您需要比较两个对象属性的相等性，这个问题有非常有帮助的答案。

Answer 2

这有什么意义？

因为对象引用的“相等”，就==and===运算符而言，纯粹基于引用是否引用同一个对象。这在抽象相等比较算法（由 使用==）和严格相等比较算法（由 使用）中明确阐述===。

在您的代码中，当您说a==bor时a===b，您不是在比较objects，而是在比较引用a并b查看它们是否引用同一个对象。这就是 JavaScript 的定义方式，并且与许多（但不是全部）其他语言中相等运算符的定义方式一致（Java、C# [除非运算符被覆盖，因为它是用于string] 和 C++ 例如）。

JavaScript 没有内置的equivalence概念，即对象之间的比较，指示它们是否等效（例如，具有相同的属性和相同的值，如 Java 的Object#equals）。您可以在自己的代码库中定义一个，但没有任何内在定义它。

Answer 3

从 Javascript 权威指南。

对象不按值比较：即使两个对象具有相同的属性和值，它们也不相等。数组也是如此：即使它们以相同的顺序具有相同的值。

var o = {x:1}, p = {x:1};  // Two objects with the same properties
o === p                    // => false: distinct objects are never equal 
var a = [], b = [];        // Two distinct, empty arrays 
a === b                    // => false: distinct arrays are never equal 

对象有时被称为引用类型，以区别于 JavaScript 的原始类型。使用这个术语，对象值是引用，我们说对象是通过引用进行比较的：两个对象值是相同的当且仅当它们引用相同的底层对象时。

var a = {};   // The variable a refers to an empty object. 
var b = a;    // Now b refers to the same object. 
b.property = 1;     // Mutate the object referred to by variable b. 
a.property          // => 1: the change is also visible through variable a. 
a === b       // => true: a and b refer to the same object, so they are equal. 

如果我们想比较两个不同的对象，我们必须比较它们的属性。

Answer 4

use JSON.stringify(objname);

var a = {name : "name1"};
var b = {name : "name1"};

var c = JSON.stringify(a);
var d = JSON.stringify(b);

c==d;
//true

Answer 5

下面是对JavaScript中{} === {}返回原因的快速解释：false

---

来自 MDN 网络文档 - Working with objects: Comparing objects.

在 JavaScript 中，对象是一种引用类型。两个不同的对象永远不会相等，即使它们具有相同的属性。只有将相同的对象引用与其自身进行比较才会产生 true。

// Two variables, two distinct objects with the same properties
var fruit = {name: 'apple'};
var fruitbear = {name: 'apple'};

fruit == fruitbear; // return false
fruit === fruitbear; // return false

// Two variables, a single object
var fruit = {name: 'apple'};
var fruitbear = fruit;  // Assign fruit object reference to fruitbear

// Here fruit and fruitbear are pointing to same object
fruit == fruitbear; // return true
fruit === fruitbear; // return true

fruit.name = 'grape';
console.log(fruitbear); // output: { name: "grape" }, instead of { name: "apple" }

有关比较运算符的详细信息，请参阅比较运算符。

Answer 6

===，对象的严格相等运算符检查身份。

如果两个对象引用同一个对象，则它们是严格相等的。

这是两个不同的对象，所以它们是不同的。

想想两张空白的纸。它们的属性相同，但它们不是一回事。如果你在其中一个上写一些东西，另一个就不会改变。

Answer 7

这有什么意义？

想象一下这两个对象：

var a = { someVar: 5 }
var b = { another: 'hi' }

现在如果你这样做了a === b，你会直觉地认为它应该是错误的（这是正确的）。但是您认为这是错误的，因为对象包含不同的键，还是因为它们是不同的对象？接下来想象从每个对象中删除键：

delete a.someVar
delete b.another

现在两者都是空对象，但相等性检查仍将完全相同，因为您仍在比较a和是否b是同一个对象（而不是它们是否包含相同的键和值）。

Answer 8

这是一种解决方法：Object.toJSON(obj1) == Object.toJSON(obj2)

通过转换为字符串，比较基本上会在字符串中

Answer 9

In Javascript each object is unique hence `{} == {}` or `{} === {}` returns false. In other words Javascript compares objects by identity, not by value.

 1. Double equal to `( == )` Ex: `'1' == 1` returns true because type is excluded 
     
 2. Triple equal to `( === )` Ex: `'1' === 1` returns false compares strictly, checks for type even