Run results for: Compare Various deep clone methods

Test name	Executions per second
✓ recursiveDeepCopy	1,403,576 Ops/sec
recursiveSpreadClone	752,627 Ops/sec
recursiveAssignClone	708,540 Ops/sec
recursiveFromEntriesClone	514,259 Ops/sec
Lodash cloneDeep	285,848 Ops/sec
tryStructuredClone	60,514 Ops/sec
Script Preparation code:
const TestObject = {
  description:
    "Creates a deep copy of source, which should be an object or an array.",
  myNumber: 123456789,
  myBoolean: true,
  jayson: {
    stringify:
      "JSON.stringify() method converts a JavaScript value to a JSON string....",
    parse: "JSON.parse() method parses a JSON string...",
  },
}
function testFn(arg1, arg2) {
  console.log({ arg1, arg2 })
}

testFn.fn_one = function (arg3, arg4) {
  console.log({ thisArg: this, arg3, arg4 })
}
testFn.str_val = "String Value"
testFn.bool_val = true
testFn.sym_val = Symbol.for("test")
testFn.obj_val = TestObject

const person = {
  name: "John Doe",
  age: 34,
  address: {
    country: "USA",
    city: "Boston",
  },
  hobbies: ["Reading", "Cooking"],
  active: true,
  signDate: new Date(),
  superPowers: new Set(["strength", "fly"]),
  knowledge: new Map([
    ["history", "good"],
    ["math", "bad"],
  ]),
  testFn,
}

function isObject(value) {
  return typeof value == "object" && value != null
}
function isFunction(value) {
  return typeof value == "function"
}

function assignFnResultForEachProperty(targetObj, srcObj, getPropValueFn) {
  const keys = Object.keys(srcObj)
  for (const k of keys) {
    if (isObject(srcObj[k]) || isFunction(srcObj[k])) {
      targetObj[k] = getPropValueFn(srcObj[k])
    }
  }
  return targetObj
}

function createFunctionWrapper (fn) {
  return function (...args) {
    return value.call(this, ...args)
  }
}


function tryStructuredClone (value) {
  if (isFunction(value)) {
    const result = createFunctionWrapper(value);
    const keys = Object.keys(value);
    for (const key of keys) {
      result[ key ] = tryStructuredClone(value[ key ]);
    }
    return result;
  }
  else if (!isObject(value)) {
    return value;
  }
  try {
    return structuredClone(value);
  }
  catch {
    const result = {};
    const keys = Object.keys(value);
    for (const key of keys) {
      result[ key ] = tryStructuredClone(value[key]);
    }
    return result;
  }
}

function recursiveDeepCopy(value) {
  let result
  if (isObject(value)) {
    if (Array.isArray(value)) {
      result = []
    }
    result = {}
  } else if (isFunction(value)) {
    result = createFunctionWrapper(value);
  } else {
    // Primitive value
    return value
  }
  for (const key in value) {
    result[key] = recursiveDeepCopy(value[key])
  }
  return result
}

function recursiveSpreadClone(value) {
  if (isObject(value)) {
    if (Array.isArray(value)) {
      const result = [...value]
      const nonIdxProps = Object.keys(value).filter((k) => !/^\d+$/.test(k))
      const otherProps = Object.fromEntries(
        nonIdxProps.map((k) => [k, value[k]])
      )
      return assignFnResultForEachProperty(
        Object.assign(result, otherProps),
        value,
        recursiveSpreadClone
      )
    }
    return assignFnResultForEachProperty(
      { ...value },
      value,
      recursiveSpreadClone
    )
  }
  if (isFunction(value)) {
    const result = createFunctionWrapper(value);
    return assignFnResultForEachProperty(
      Object.assign(result, { ...value }),
      value,
      recursiveSpreadClone
    )
  }
  // Primitive value
  return value
}
function recursiveAssignClone(value) {
  if (isObject(value)) {
    if (Array.isArray(value)) {
      return assignFnResultForEachProperty(
        Object.assign([], value),
        value,
        recursiveAssignClone
      )
    }
    return assignFnResultForEachProperty(
      Object.assign({}, value),
      value,
      recursiveAssignClone
    )
  }
  if (isFunction(value)) {
    const result = createFunctionWrapper(value);
    return assignFnResultForEachProperty(
      Object.assign(result, { ...value }),
      value,
      recursiveAssignClone
    )
  }
  // Primitive value
  return value
}

var myCopy = null


function recursiveFromEntriesClone(value) {
  if (isObject(value)) {
    if (Array.isArray(value)) {
      const result = value.map(recursiveFromEntriesClone)
      const nonIdxProps = Object.keys(value).filter((k) => !/^\d+$/.test(k))
      const otherProps = Object.fromEntries(
        nonIdxProps.map((k) => [k, value[k]])
      )
      return assignFnResultForEachProperty(
        Object.assign(result, otherProps),
        otherProps,
        recursiveFromEntriesClone
      )
    }
    const result = Object.fromEntries(
      Object.keys(value).map((k) => [k, value[k]])
    )
    return assignFnResultForEachProperty(
      result,
      value,
      recursiveFromEntriesClone
    )
  }
  if (isFunction(value)) {
    const result = createFunctionWrapper(value);
    const otherProps = Object.fromEntries(
      Object.keys(value).map((k) => [k, value[k]])
    )
    return assignFnResultForEachProperty(
      Object.assign(result, otherProps),
      value,
      recursiveFromEntriesClone
    )
  }
  // Primitive value
  return value
}

function logResultsOfEach () {
  var lodash_res = _.cloneDeep(person);
  var deepCopy_res = recursiveDeepCopy(person)
  var spread_res = recursiveSpreadClone(person)
  var assign_res = recursiveAssignClone(person)
  var entries_res = recursiveFromEntriesClone(person)
  var structured_res = tryStructuredClone(person);
  
  var r = {
    lodash: lodash_res,
    deepCopy: deepCopy_res,
    spread: spread_res,
    assign: assign_res,
    entries: entries_res,
    structured: structured_res
  }
  console.log(r);
}
logResultsOfEach();
Run results for: Compare Various deep clone methods

Lodash cloneDeep

tryStructuredClone

recursiveDeepCopy

recursiveSpreadClone

recursiveAssignClone

recursiveFromEntriesClone
