DEV Community

What's the best way to deeply clone an object in JavaScript?

Jasterix on August 01, 2020

I recently attempted a code challenge where I needed to deeply clone an object. Prior to this I learned to do this by converting it to JSON. But ac...

Read full post

TJ Johnson • Aug 3 '20

A library is just a collection of solutions written in a way that they can be reusable. Here is the module in lodash that contains the logic for the deep clone github.com/lodash/lodash/blob/mast..., it's imported from this module github.com/lodash/lodash/blob/mast..., which is the module you would use in your code.

Pacharapol Withayasakpunt • Aug 1 '20 • Edited

There seems to be no native way, but it is as simple as,

function deepClone(o) {
  /**
   * This excludes null
   */
  if (o && typeof o === 'object') {
    if (Array.isArray(o)) {
      return o.map((a) => deepClone(a))
    } else if (o.constructor === Object) {
      return Object.entries(o).reduce((prev, [k, v]) => ({ ...prev, [k]: deepClone(v) }), {})
    }

    /**
     * Now it depends on how you would recreate the Object, or not...
     */
    return o
  }

  /**
   * BTW, function is another important case you might consider...
   */
  return o
}

A perfect way is simply,

/**
 * Yes, that dangerousLoad
 * js-yaml's dump also supports several options
 */
yaml.load(yaml.dump(o))

Jasterix • Aug 2 '20

This is helpful. Thanks!!

Peter Vivo • Aug 6 '20 • Edited

Are you means?

const base = {
  a: {
   b: [1,2,4],
   c: 'call me c'
  }, 
  d: p => p * 2, 
  get orig(){ return base}
};

const result = deepCopy(base);

test cases (mandatory true)

  result.a !== test.a
  result.a.b !== test.a.b
  result.a.c === test.a.c
  result.d !== test.d
  result.d(42) === test.d(42)
  test.orig === test
  result.orig === test
  result.orig !== result

Jasterix • Aug 9 '20

This is awesome! Thanks for also adding the test cases

Jalal 🚀 • Aug 2 '20

const deeplyCloned = object.assign({}, myObj)

Mihai • Oct 15 '20

If it's not a nested object, it's really nice to use the spread operator
const newObject = { ..currentObject };

If it's a nested or deeply nested object, it's much safer to use
const newObject = JSON.parse(JSON.stringify(currentObject))

in a nutshell:
const cloneDeep = (obj) => {
return JSON.parse(JSON.stringify(obj))
}

I should say i haven't taken the time to see any performance detriments, if any, appear.

Jalal 🚀 • Aug 5 '20

cloning nested object is like diving into a black hole

Kevin Steele • Aug 6 '20

let obj = {stuff: {
more_stuff: "this",
list: [1,2,3]},
}

JSON.parse(JSON.stringify(obj))

Jasterix • Aug 9 '20

This is only a shallow clone so nested reference types would not be cloned

Kevin Steele • Feb 19 '21

developer.mozilla.org/en-US/docs/W...