Direct response

To compare whether two objects are "twins", first determine whether they are "children" of the same "parent" and then whether they have the same "DNA", i.e. that the objects are instances of the same object and the properties are the same ( name , order, attributes and values).

NOTE: For simplicity in the metaphor, other elements such as body parts are not considered.

If you are not interested in them being "twins" but only some items being the same, then compare those items.

Here is a brief example on how to know if two objects are instances of the same object and, for brevity, if they have the same properties, meaning that the properties of both have the same name and that their position is the same.

// Crear constructor personalizado
function vivienda() {
  var puerta;
};

// Crear objeto casa
var casa = new vivienda();
casa.puerta = 1;

// Crear objeto residencia
var residencia = new vivienda();
residencia.puerta = 2;

/* Si los objetos son hermanos 
 * entonces verificar que sus propiedades 
 * tengan el mismo nombre y en el mismo orden */
if (casa instanceof vivienda && residencia instanceof vivienda) {
  console.log('Casa y Residencia son instancias de vivienda por lo tanto son comparables');
  var conclusion = (Object.getOwnPropertyNames(casa).toString() == Object.getOwnPropertyNames(residencia).toString()) ?
  'Tienen las misma estructura': 'No tienen la misma estructura';
  console.log('Conclusión: ' + conclusion);
  
} else {
  console.log('Casa ó Residencia no son instancias de vivienda y por lo tanto no son comparables');
}

// Mostrar los nombres y valores de las propiedades de cada objeto
console.log('** casa **' + Object.getOwnPropertyNames(casa));
Object.getOwnPropertyNames(casa).forEach(
  function(val, idx, array) {
    console.log(val + ' -> ' + casa[val]);
  }
)
console.log('** vivienda **');
Object.getOwnPropertyNames(residencia).forEach(
  function(val, idx, array) {
    console.log(val + ' -> ' + residencia[val]);
  }
)

Explanation

Note on question content: Comparisons of various types of operands are included in the first block of code. In the second block of code, variables assigned to objects created with nested operations are compared. From this it can be concluded that the confusion is due to ignorance of some of the essential concepts of JavaScript and Software Engineering. Considering this, an abbreviated explanation covering some key concepts is presented below.

The "must" of a comparison is stated by the purpose and in the case of JavaScript even more so.

Compared to other programming languages, JavaScript could be considered very flexible since the algorithms for how operations should be performed take into account the types of the operands.

Considering the above when implementing a comparison in JavaScript we must keep in mind:

1. Variables are references to objects.
2. Objects have properties.
3. Properties can be objects or functions (the latter are also called methods).
4. Properties have attributes.
5. Except for primitives, objects inherit properties and functions from a prototype.

Considering the above as well as the premise of being a flexible language, JavaScript includes two types of comparisons, strict and abstract, each of which has its own algorithm, which are described in the ECMAScript specifications. Below are the links to the corresponding sections of version 5.

• The Abstract Equality Comparison Algorithm
• The Strict Equality Comparison Algorithm

In summary

• A strict comparison of two objects returns false because it is so specified in the specification. The logic of this is similar to the legal identity of "twins" in "Western" countries, although they have the same parents, each one is registered with a different name and each one has the rights and obligations as independent individuals according to their individual conditions. .

• The result of an abstract comparison of two objects is "confusing" because it varies depending on the type of the objects.

I assume we are talking about comparing values ​​that two objects store. In that case, what @M.Gress mentions is only valid if both objects are identical even in the order of their properties , which is not very useful. The ideal way would be to compare all properties even non-enumerable ones, but this is not possible, at least not in all browsers.

How do comparison operators work?

In the darkest part of JavaScript, where evil and confusion reigns, there are two groups of comparison operators:

• strict group
• non-strict group

The strict group includes the operators ===and !==, while the non-strict group includes -as teacher Douglas Cockford would say in his book "JavaScript: the good parts"- their evil twins ==and !=. This last group should be avoided at all costs because they are the cause of many headaches.

non-strict group

This group of equality operators should be avoided as much as possible, in fact, I would recommend that you forget about their existence. A key point to understand the source of problems when using the operators is the following: the equality comparison in JavaScript is not transitive . What does this mean? Let's see it in the following code:

let foo = 'foo';
let foo2 = new String('foo');
let foo3 = new String('foo');

console.log(foo == foo2);
console.log(foo2 == foo3);
console.log(foo == foo3);

Why does the comparison between fooand foo3result in falsewhen they are equal values?

Well, the answer is a bit tricky. To understand why this happens, we need to understand how the comparison is done internally .

JavaScript uses performs two processes when comparing two variables:

• ToNumber
• ToPrimitive

What does this mean? It means the following. If you compare two variables that are not objects, if they are internally different, they are converted to numbers usingToNumber , and then perform a strict comparison . This is why this is true:

'123' == 123 // Number('123') === 123 -> true
1   == '1'    // 1 === Number('1') -> true
0   == false  // 0 === Number(false) -> true

This also applies to booleans since a boolean in decimal representation will be 0 or 1. However, something different happens when you compare a variable X with an object or two objects: here operand A or B (whichever is object) is evaluated withToPrimitive , this inner method simply makes recursive calls to toStringand valueOfto get some primitive value. Subsequently, it makes use of ToNumberto perform a comparison.

If you compare two objects, basically the non-strict equality operator will return true when they compare the same reference in memory:

let foo = { bar: 'bar' }
let clone = foo;

console.log(foo == clone);

strict group

Here there are no detours, first it is verified that it is the same data type, then values ​​are compared.

How to compare two objects?

If we talk about literal objects and comparing their own properties , it is enough to iterate the properties of both objects. For example:

function areObjEquals (obj1, obj2) {
  let equal = true;

  for (let [key, val] of Object.entries(foo)) {
    if (bar.hasOwnProperty(key))   {
      if (bar[key] !== val) {
        equal = false;
      }
    } else {
      equal = false;
    }

    if (!equal) { break; }
  }

  return equal;
}