¿Por qué dos objetos idénticos no son iguales entre sí?

La única diferencia entre regular (==) y estricto (===) igualdad es que el operador de igualdad estricta deshabilita la conversión de tipos. Dado que ya está comparando dos variables del mismo tipo, el tipo de operador de igualdad que utilice no importa.

Independientemente de si usa la igualdad regular o estricta, las comparaciones de objetos solo se evalúan para true si comparas el mismo objeto exacto.

Es decir, dado var a = {}, b = a, c = {};, a == a, a == b, pero a != c.

Dos objetos diferentes (incluso si ambos tienen cero o las mismas propiedades exactas) nunca se compararán por igual. Si necesita comparar la igualdad de las propiedades de dos objetos, esta pregunta tiene respuestas muy útiles.

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

Aquí hay una explicación rápida de por qué {} === {} devoluciones false en JavaScript:

De MDN Web Docs - Working with objects: Comparing objects.

En JavaScript, los objetos son un tipo de referencia. Dos objetos distintos nunca son iguales, aunque tengan las mismas propiedades. Solo comparando la misma referencia de objeto consigo misma se obtiene la verdad.

// 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" }

Para obtener más información acerca de los operadores de comparación, consulte Operadores de comparación.

¿Cómo esto tiene sentido?

Debido a que la "igualdad" de las referencias de objeto, en términos de la == y === operadores, es puramente en función de si las referencias se refieren a la mismo objeto. Esto está claramente establecido en el algoritmo de comparación de igualdad abstracta (usado por ==) y el algoritmo de comparación de igualdad estricta (usado por ===).

En tu código, cuando dices a==b or a===b, no estás comparando el objetos, estás comparando las referencias en a y b para ver si se refieren al mismo objeto. Así es como se define JavaScript, y en línea con la forma en que se definen los operadores de igualdad en muchos (pero no en todos) otros lenguajes (Java, C# [a menos que se anule el operador, como es para string] y C++, por ejemplo).

JavaScript no tiene un concepto incorporado de equivalencia, una comparación entre objetos que indica si son equivalentes (por ejemplo, si tienen las mismas propiedades con los mismos valores, como los de Java). Object#equals). Puede definir uno dentro de su propia base de código, pero no hay nada intrínseco que lo defina.

A partir de La Guía Definitiva de Javascript.

Los objetos no se comparan por valor: dos objetos no son iguales aunque tengan las mismas propiedades y valores. Esto también es cierto para las matrices: incluso si tienen los mismos valores en el mismo orden.

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 

Los objetos a veces se denominan tipos de referencia para distinguirlos de los tipos primitivos de JavaScript. Usando esta terminología, los valores de los objetos son referencias, y decimos que los objetos se comparan por referencia: dos valores de objetos son iguales si y solo si se refieren al mismo objeto subyacente.

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. 

Si queremos comparar dos objetos distintos debemos comparar sus propiedades.

Esta es una solución alternativa: Object.toJSON(obj1) == Object.toJSON(obj2)

Al convertir a cadena, la comprasion será básicamente en cadenas

¿Cómo esto tiene sentido?

Imagina estos dos objetos:

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

Ahora si lo hicieras a === b, intuitivamente pensaría que debería ser falso (lo cual es correcto). Pero, ¿crees que es falso porque los objetos contienen claves diferentes, o porque son diferentes objetos? A continuación, imagina quitar las llaves de cada objeto:

delete a.someVar
delete b.another

Ambos son ahora objetos vacíos, pero la verificación de igualdad seguirá siendo exactamente la misma, porque todavía está comparando si o no. a y b son el mismo objeto (no si contienen las mismas claves y valores).

===, la estrictamente igual El operador de objetos comprueba la identidad.

Dos objetos son estrictamente iguales si se refieren al mismo Objeto.

Esos son dos objetos diferentes, por lo que difieren.

Piensa en dos páginas de papel vacías. Sus atributos son los mismos, pero no son lo mismo. Si escribes algo en uno de ellos, el otro no cambiaría.

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