Interview

index.js

/**
 Реализуйте функцию deepEqual на JavaScript,
 которая принимает два параметра и проверяет, являются ли они "глубоко" равными.

 Входные параметры не могут быть объектами типа Set, Map и их Weak-версиями.

 Функция должна учитывать следующие правила:
 - Примитивные типы (числа, строки, булевы значения, null, undefined) сравниваются по значению.
 - Массивы считаются равными, если они имеют одинаковую длину и их элементы попарно равны (в том же порядке).
 - Объекты считаются равными, если они имеют одинаковый набор ключей и значения по этим ключам попарно равны.
 - Функция должна корректно обрабатывать рекурсивные структуры (объекты и массивы, которые содержат ссылки на самих себя).
 */


function deepEqual(v1, v2) {
  
}

const recursive = (object, property) => {
  object[property] = object;

  return object;
};

const testData = [
  { value1: 42, value2: 42, expected: true }, // 0
  { value1: "hello", value2: "hello", expected: true }, // 1
  { value1: true, value2: true, expected: true }, // 2
  { value1: null, value2: null, expected: true }, // 3
  { value1: undefined, value2: undefined, expected: true }, // 4
  { value1: null, value2: {}, expected: false }, // 5
  { value1: null, value2: undefined, expected: false }, // 6
  { value1: { a: 1, b: 2 }, value2: { a: 1, b: 2 }, expected: true }, // 7
  { value1: { a: 1, b: 2 }, value2: { b: 2, a: 1 }, expected: true }, // 8
  { value1: { a: 1, b: 2 }, value2: { a: 1, b: 3 }, expected: false }, // 9
  {
    // 10
    value1: { a: undefined, b: 1 },
    value2: { b: 1, c: true },
    expected: false,
  },
  { value1: [1, 2, 3], value2: [1, 2, 3, 4], expected: false }, // 11
  { value1: [1, 2, [3, 4]], value2: [1, 2, [3, 4]], expected: true }, // 12
  {
    // 13
    value1: {
      a: { b: { c: [{ d: "e", f: [1, 2, "321", null], g: undefined }] } },
      h: [{ i: "j", k: { l: "m", n: [null, false, ""] } }],
      o: { p: "q", r: [1, 2, [3, 4, [5, 6]]] },
      s: { t: [{ u: "v", w: { x: "y", z: [true, false, null] } }] },
    },
    value2: {
      a: { b: { c: [{ d: "e", f: [1, 2, "321", null], g: undefined }] } },
      h: [{ i: "j", k: { l: "m", n: [null, false, ""] } }],
      o: { p: "q", r: [1, 2, [3, 4, [5, 6]]] },
      s: { t: [{ u: "v", w: { x: "y", z: [true, false, null] } }] },
    },
    expected: true,
  },
  // {
  //   // 14
  //   value1: recursive(
  //     {
  //       a: { b: { c: [{ d: "e", f: [1, 2, "321", null], g: undefined }] } },
  //       h: [{ i: "j", k: { l: "m", n: [null, false, ""] } }],
  //       o: { p: "q", r: [1, 2, [3, 4, [5, 6]]] },
  //       s: { t: [{ u: "v", w: { x: "y", z: [true, false, null] } }] },
  //     },
  //     "self"
  //   ),
  //   value2: recursive(
  //     {
  //       a: { b: { c: [{ d: "e", f: [1, 2, "321", null], g: undefined }] } },
  //       h: [{ i: "j", k: { l: "m", n: [null, false, ""] } }],
  //       o: { p: "q", r: [1, 2, [3, 4, [5, 6]]] },
  //       s: { t: [{ u: "v", w: { x: "y", z: [true, false, null] } }] },
  //     },
  //     "self"
  //   ),
  //   expected: true,
  // },
  // {
  //   // 15
  //   value1: recursive(
  //     {
  //       a: { b: { c: [{ d: "e", f: [1, 2, "321", null], g: undefined }] } },
  //       h: [{ i: "j", k: { l: "m", n: [null, false, ""] } }],
  //       o: { p: "q", r: [1, 2, [3, 4, [5, 6]]] },
  //     },
  //     "self"
  //   ),
  //   value2: recursive(
  //     {
  //       a: { b: { c: [{ d: "e", f: [1, 2, "321", null], g: undefined }] } },
  //       h: [{ i: "j", k: { l: "m", n: [null, true, ""] } }],
  //       o: { p: "q", r: [2, 2, [3, 4, [5, 6]]] },
  //     },
  //     "self"
  //   ),
  //   expected: false,
  // },
];

testData.forEach(({ value1, value2, expected }, idx) => {
  const result = deepEqual(value1, value2);
  console.assert(
    result === expected,
    `Expected ${expected}, but got ${result}, for test ${idx}`
  );
});

console.log("done");