[
  { "id": 1, "name": "Learn React", "status": "active" },
  { "id": 2, "name": "Learn React Query", "status": "todo" }
]

[
- { "id": 1, "name": "Learn React", "status": "active" },
+ { "id": 1, "name": "Learn React", "status": "done" },
  { "id": 2, "name": "Learn React Query", "status": "todo" }
]

const a = [1, 2, 3]
const b = [1, 2, 3]

console.log(a === b) // ?

/* eslint-disable no-prototype-builtins */
export function isPlainArray(value: unknown) {
  return Array.isArray(value) && value.length === Object.keys(value).length;
}

function hasObjectPrototype(o: any): boolean {
  return Object.prototype.toString.call(o) === '[object Object]';
}

// Copied from: https://github.com/jonschlinkert/is-plain-object
export function isPlainObject(o: any): o is object {
  if (!hasObjectPrototype(o)) {
    return false;
  }

  // If has no constructor
  const ctor = o.constructor;
  if (ctor === undefined) {
    return true;
  }

  // If has modified prototype
  const prot = ctor.prototype;
  if (!hasObjectPrototype(prot)) {
    return false;
  }

  // If constructor does not have an Object-specific method
  if (!prot.hasOwnProperty('isPrototypeOf')) {
    return false;
  }

  // Handles Objects created by Object.create(<arbitrary prototype>)
  if (Object.getPrototypeOf(o) !== Object.prototype) {
    return false;
  }

  // Most likely a plain Object
  return true;
}

/**
 * This function returns `a` if `b` is deeply equal.
 * If not, it will replace any deeply equal children of `b` with those of `a`.
 * This can be used for structural sharing between JSON values for example.
 */
export function replaceEqualDeep<T>(a: unknown, b: T): T;
export function replaceEqualDeep(a: any, b: any): any {
  // a와 b가 primitive type 혹은 a와 b가 같은 참조값이면 a를 반환
  if (a === b) {
    return a;
  }

  const array = isPlainArray(a) && isPlainArray(b);

  // 둘 다 배열이거나 둘 다 plain object면
  if (array || (isPlainObject(a) && isPlainObject(b))) {
    const aItems = array ? a : Object.keys(a);
    const aSize = aItems.length;
    const bItems = array ? b : Object.keys(b);
    const bSize = bItems.length;
    // 복사본을 저장할 배열 또는 object
    const copy: any = array ? [] : {};

    let equalItems = 0;

    for (let i = 0; i < bSize; i++) {
      const key = array ? i : bItems[i];
      // (배열 aItems에 있는 key이거나 a,b 둘 다 배열이고) && a[key]와 b[key]가 undefined이면
      if (((!array && aItems.includes(key)) || array) && a[key] === undefined && b[key] === undefined) {
        // 복사본에 해당 키의 값은 undefined로 저장
        copy[key] = undefined;
        // 둘 다 undefined로 같기 때문에 equalItems++
        equalItems++;
      } else {
        // 값이 undefined가 아니면 재귀적으로 replaceEqualDeep 호출
        copy[key] = replaceEqualDeep(a[key], b[key]);
        // 실질적으로 여기서 deep equal한지 확인
        // replaceEqualDeep에서 아래 return 문에서 a가 나왔으면 바로 밑 조건문 통과 equalItems++
        if (copy[key] === a[key] && a[key] !== undefined) {
          equalItems++;
        }
      }
    }

    // bSize가 0이거나 for문 전부 다 순회했을 때 aSize와 equalItems가 같으면 a를 반환
    return aSize === bSize && equalItems === aSize ? a : copy;
  }

  // a와 b가 다른 타입 혹은 다른 값일 경우 b를 반환
  return b;
}