Прямой ответ

Чтобы сравнить, являются ли два объекта «близнецами», сначала определите, являются ли они «потомками» одного и того же «родителя», а затем определите, имеют ли они одинаковую «ДНК», т. е. объекты являются экземплярами одного и того же объекта, а свойства являются одинаковые (имя, порядок, атрибуты и значения).

ПРИМЕЧАНИЕ. Для простоты метафоры другие элементы, такие как части тела, не учитываются.

Если вы не заинтересованы в том, чтобы они были «близнецами», а только в том, чтобы некоторые элементы были одинаковыми, сравните эти элементы.

Вот краткий пример того, как узнать, являются ли два объекта экземплярами одного и того же объекта и, для краткости, имеют ли они одинаковые свойства, что означает, что свойства обоих имеют одно и то же имя и что их положение одинаково.

// 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]);
  }
)

Объяснение

Примечание к содержанию вопроса: сравнения различных типов операндов включены в первый блок кода. Во втором блоке кода сравниваются переменные, присвоенные объектам, созданным с помощью вложенных операций. Из этого можно сделать вывод, что путаница происходит из-за незнания некоторых основных концепций JavaScript и разработки программного обеспечения. Учитывая это, ниже представлено сокращенное объяснение, охватывающее некоторые ключевые понятия.

Необходимость сравнения определяется целью, а в случае JavaScript тем более.

По сравнению с другими языками программирования JavaScript можно считать очень гибким, поскольку алгоритмы выполнения операций учитывают типы операндов.

Учитывая вышеизложенное, при реализации сравнения в JavaScript мы должны помнить:

1. Переменные — это ссылки на объекты.
2. Объекты имеют свойства.
3. Свойства могут быть объектами или функциями (последние также называются методами).
4. Свойства имеют атрибуты.
5. За исключением примитивов, объекты наследуют свойства и функции прототипа.

Учитывая вышеизложенное, а также предпосылку гибкости языка, JavaScript включает два типа сравнений, строгое и абстрактное, каждое из которых имеет собственный алгоритм, описанный в спецификациях ECMAScript. Ниже приведены ссылки на соответствующие разделы версии 5.

• Алгоритм сравнения абстрактного равенства
• Алгоритм сравнения строгого равенства

В итоге

• Строгое сравнение двух объектов возвращает false, поскольку это указано в спецификации. Логика этого аналогична юридической идентичности «близнецов» в «западных» странах, хотя у них одни и те же родители, каждый зарегистрирован под другим именем, и каждый имеет права и обязанности как независимые лица в соответствии со своими индивидуальными условия. .

• Результат абстрактного сравнения двух объектов «сбивает с толку», потому что он варьируется в зависимости от типа объектов.

Я предполагаю, что мы говорим о сравнении значений , которые хранят два объекта. В этом случае то, что упоминает @M.Gress, действительно только в том случае, если оба объекта идентичны даже в порядке их свойств , что не очень полезно. Идеальным способом было бы сравнение всех свойств, даже неперечислимых, но это невозможно, по крайней мере, не во всех браузерах.

Как работают операторы сравнения?

В самой темной части JavaScript, где царит зло и неразбериха, есть две группы операторов сравнения:

• строгая группа
• нестрогая группа

В строгую группу входят операторы ===и !==, в то время как в нестрогую группу входят, как сказал бы учитель Дуглас Кокфорд в своей книге «JavaScript: хорошие стороны», их злые близнецы ==и !=. Этой последней группы следует избегать любой ценой, потому что они являются причиной многих головных болей.

нестрогая группа

Эту группу операторов равенства следует по возможности избегать, более того, я бы рекомендовал вам забыть об их существовании. Ключевым моментом для понимания источника проблем при использовании операторов является следующее: сравнение на равенство в JavaScript не является транзитивным . Что это значит? Давайте посмотрим на это в следующем коде:

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);

Почему сравнение между fooи foo3приводит к тому false, что они равны?

Что ж, ответ немного сложен. Чтобы понять, почему это происходит, нам нужно понять , как выполняется внутреннее сравнение .

JavaScript использует два процесса при сравнении двух переменных:

• ToNumber
• ToPrimitive

Что это значит? Это означает следующее. Если вы сравниваете две переменные, которые не являются объектами, если они внутренне различны, они преобразуются в числа с помощьюToNumber , а затем выполняется строгое сравнение . Вот почему это верно:

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

Это также относится к логическим значениям, поскольку логическое значение в десятичном представлении будет равно 0 или 1. Однако при сравнении переменной X с объектом или двумя объектами происходит нечто иное: здесь операнд A или B (в зависимости от того, какой объект) оценивается с помощьюToPrimitive , это внутренний метод просто делает рекурсивные вызовы toStringи valueOfдля получения некоторого примитивного значения. Впоследствии он использует ToNumberдля выполнения сравнения.

Если вы сравниваете два объекта, в основном оператор нестрогого равенства возвращает true, когда они сравнивают одну и ту же ссылку в памяти:

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

console.log(foo == clone);

строгая группа

Здесь обходных путей нет, сначала проверяется, что это один и тот же тип данных, затем сравниваются значения.

Как сравнить два объекта?

Если говорить о литеральных объектах и ​​сравнении их собственных свойств , то достаточно перебрать свойства обоих объектов. Например:

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;
}