What is the most efficient way to deep clone an object in JavaScript

Question

What is the most efficient way to clone a JavaScript object  I ve seen obj   eval uneval o    being used  but that s non-standard and only supported by Firefox  I ve done things like obj   JSON parse JSON stringify o    but question the efficiency   I ve also seen recursive copying functions with various flaws   I m surprised no canonical solution exists

User · Answer

Requires new-ish browsers  but     Let s extend the native Object and get a real  extend     Object defineProperty Object prototype   extend         enumerable  false      value  function            var that   this           Array prototype slice call arguments  map function source               var props   Object getOwnPropertyNames source                   i   0  l   props length                  prop               for   i  lt  l    i                   prop   props i                    if that hasOwnProperty prop   amp  amp  typeof that prop        object                        that prop    that prop  extend source prop                     else                      Object defineProperty that  prop  Object getOwnPropertyDescriptor source  prop                                                         return this              Just pop that in prior to any code that uses  extend   on an object   Example   var obj1         node1   1       node2   2       node3  3     var obj2         node1   4       node2  5      node3   6      var obj3        extend obj1  obj2    console log obj3      Object  node1   4   node2  5  node3   6

User · Answer

For future reference  one can use this code  ES6    clone  function obj       let newObj           for let i in obj           if typeof obj i        object   amp  amp  Object keys obj i   length               newObj i    clone obj i              else              newObj i    obj i                       return Object assign    newObj       ES5   function clone obj   let newObj       for let i in obj       if typeof obj i        object   amp  amp  Object keys obj i   length           newObj i    clone obj i          else          newObj i    obj i           return Object assign    newObj        E g   var obj   a  b 1 c 3  d 4 e  f 6   var xc   clone obj   console log obj      a  b 1 c 3  d 4 e  f 6   console log xc      a  b 1 c 3  d 4 e  f 6    xc a b   90  console log obj      a  b 1 c 3  d 4 e  f 6   console log xc      a  b 90 c 3  d 4 e  f 6

User · Answer

I know this is an old post  but I thought this may be of some help to the next person who stumbles along   As long as you don t assign an object to anything it maintains no reference in memory   So to make an object that you want to share among other objects  you ll have to create a factory like so   var a   function        return           father  zacharias            b   a    c   a    c father    johndoe   alert b father

User · Answer

This isn t generally the most efficient solution  but it does what I need  Simple test cases below     function clone obj  clones           Makes a deep copy of  obj   Handles cyclic structures by        tracking cloned obj s in the  clones  parameter  Functions         are included  but not cloned  Functions members are cloned      var new obj          already cloned          t   typeof obj          i   0          l          pair        clones   clones             if  obj     null            return obj             if  t      object     t      function                 check to see if we ve already cloned obj         for  i   0  l   clones length  i  lt  l  i                  pair   clones i               if  pair 0      obj                    already cloned   pair 1                   break                                   if  already cloned                return already cloned             else               if  t      object        create new object                 new obj   new obj constructor                  else      Just use functions as is                 new obj   obj                             clones push  obj  new obj       keep track of objects we ve cloned              for  key in obj       clone object members                 if  obj hasOwnProperty key                         new obj key    clone obj key   clones                                                       return new obj    obj      Cyclic array test     a      a push  b    c   a  aa   clone a  aa     a     gt  false aa 2      a     gt  false aa 2      a 2      gt  false aa 2      aa     gt  true   Function test     f   new Function f a   a ff   clone f  ff     f     gt  true ff a     a     gt  false

User · Answer

Hope this helps   function deepClone obj                  Duplicates an object               var ret   null      if  obj     Object obj        primitive types         return obj            if  obj instanceof String    obj instanceof Number    obj instanceof Boolean       string objecs         ret   obj     for ex  obj   new String  Spidergap         else if  obj instanceof Date       date         ret   new obj constructor          else         ret   Object create obj constructor prototype        var prop   null      var allProps   Object getOwnPropertyNames obj     gets non enumerables also       var props           for  var i in allProps            prop   allProps i           props prop    false             for  i in obj            props i    i               now props contain both enums and non enums      var propDescriptor   null      var newPropVal   null     value of the property in new object     for  i in props            prop   obj i           propDescriptor   Object getOwnPropertyDescriptor obj  i            if  Array isArray prop       not backward compatible             prop   prop slice       to copy the array           else         if  prop instanceof Date    true                prop   new prop constructor              else         if  prop instanceof Object    true                if  prop instanceof Function    true       function                 if   Function prototype clone                        Function prototype clone   function                             var that   this                          var temp   function tmp                                 return that apply this  arguments                                                      for  var ky in this                                temp ky    this ky                                                     return temp                                                          prop   prop clone                   else    normal object                                prop   deepClone prop                                     newPropVal                 value  prop                    if  propDescriptor                                  If property descriptors are there  they must be copied                             newPropVal enumerable   propDescriptor enumerable              newPropVal writable   propDescriptor writable                     if   ret hasOwnProperty i      when String or other predefined objects             Object defineProperty ret  i  newPropVal      non enumerable            return ret      https   github com jinujd Javascript-Deep-Clone

User · Answer

The efficient way to clone not deep-clone  an object in one line of code An Object assign method is part of the ECMAScript 2015  ES6  standard and does exactly what you need  var clone   Object assign     obj     The Object assign   method is used to copy the values of all enumerable own properties from one or more source objects to a target object   Read more    The polyfill to support older browsers  if   Object assign      Object defineProperty Object   assign         enumerable  false      configurable  true      writable  true      value  function target           use strict         if  target     undefined    target     null            throw new TypeError  Cannot convert first argument to object                   var to   Object target         for  var i   1  i  lt  arguments length  i              var nextSource   arguments i           if  nextSource     undefined    nextSource     null              continue                    nextSource   Object nextSource            var keysArray   Object keys nextSource           for  var nextIndex   0  len   keysArray length  nextIndex  lt  len  nextIndex                var nextKey   keysArray nextIndex             var desc   Object getOwnPropertyDescriptor nextSource  nextKey             if  desc     undefined  amp  amp  desc enumerable                to nextKey    nextSource nextKey                                       return to

User · Answer

Here is my way of deep cloning a object with ES2015 default value and spread operator   const makeDeepCopy    obj  copy         gt      for  let item in obj        if  typeof obj item       object           makeDeepCopy obj item   copy            if  obj hasOwnProperty item           copy                obj                     return copy      x000D   x000D  const testObj     x000D     type    object   x000D     properties     x000D       userId     x000D         type    string   x000D         chance    guid  x000D         x000D       emailAddr     x000D         type    string   x000D         chance     x000D           email     x000D             domain    fake com  x000D            x000D           x000D         pattern       fake com  x000D        x000D       x000D     required     x000D       userId   x000D       emailAddr  x000D      x000D    x000D   x000D  const makeDeepCopy    obj  copy         gt    x000D    for  let item in obj    x000D      if  typeof obj item       object     x000D        makeDeepCopy obj item   copy  x000D        x000D      if  obj hasOwnProperty item     x000D        copy     x000D             obj x000D          x000D        x000D      x000D    return copy x000D    x000D   x000D  console log makeDeepCopy testObj   x000D   x000D   x000D

User · Answer

Code      extends  from  object with members from  to   If  to  is null  a deep clone of  from  is returned function extend from  to        if  from    null    typeof from     object   return from      if  from constructor    Object  amp  amp  from constructor    Array  return from      if  from constructor    Date    from constructor    RegExp    from constructor    Function            from constructor    String    from constructor    Number    from constructor    Boolean          return new from constructor from        to   to    new from constructor         for  var name in from                to name    typeof to name      undefined    extend from name   null    to name              return to      Test   var obj         date  new Date        func  function q    return 1   q         num  123      text   asdasd       array   1   asd        regex  new RegExp  aaa i       subobj                num  234          text   asdsaD           var clone   extend obj

User · Answer

Only when you can use ECMAScript 6 or transpilers   Features    Won t trigger getter setter while copying  Preserves getter setter  Preserves prototype informations  Works with both object-literal and functional OO writing styles    Code   function clone target  source        for let key in source               Use getOwnPropertyDescriptor instead of source key  to prevent from trigering setter getter          let descriptor   Object getOwnPropertyDescriptor source  key           if descriptor value instanceof String               target key    new String descriptor value                     else if descriptor value instanceof Array               target key    clone     descriptor value                     else if descriptor value instanceof Object               let prototype   Reflect getPrototypeOf descriptor value               let cloneObject   clone     descriptor value               Reflect setPrototypeOf cloneObject  prototype               target key    cloneObject                    else               Object defineProperty target  key  descriptor                       let prototype   Reflect getPrototypeOf source       Reflect setPrototypeOf target  prototype       return target

User · Answer

There seems to be no ideal deep clone operator yet for array-like objects   As the code below illustrates  John Resig s jQuery cloner turns arrays with non-numeric properties into objects that are not arrays  and RegDwight s JSON cloner drops the non-numeric properties  The following tests illustrate these points on multiple browsers   function jQueryClone obj       return jQuery extend true      obj     function JSONClone obj       return JSON parse JSON stringify obj      var arrayLikeObj     1   a    b     2   b    a     arrayLikeObj names     m    n    o    var JSONCopy   JSONClone arrayLikeObj   var jQueryCopy   jQueryClone arrayLikeObj    alert  Is arrayLikeObj an array instance      arrayLikeObj instanceof Array            nIs the jQueryClone an array instance       jQueryCopy instanceof Array            nWhat are the arrayLikeObj names      arrayLikeObj names           nAnd what are the JSONClone names      JSONCopy names

User · Answer

AngularJS  Well if you re using angular you could do this too  var newObject   angular copy oldObject

User · Answer

function clone obj     var clone          clone prototype   obj prototype     for  property in obj  clone property    obj property      return clone

User · Answer

Lodash has a nice   cloneDeep value  method   var objects       a   1       b   2      var deep     cloneDeep objects   console log deep 0      objects 0         gt  false

User · Answer

I disagree with the answer with the greatest votes here  A Recursive Deep Clone is much faster than the JSON parse JSON stringify obj   approach mentioned     Jsperf ranks it number one here  https   jsperf com deep-copy-vs-json-stringify-json-parse 5 Jsben from the answer above updated to show that a recursive deep clone beats all the others mentioned  http   jsben ch 13YKQ   And here s the function for quick reference   function cloneDeep  o      let newO   let i    if  typeof o      object   return o    if   o  return o    if  Object prototype toString apply o        object Array          newO          for  i   0  i  lt  o length  i    1          newO i    cloneDeep o i             return newO        newO        for  i in o        if  o hasOwnProperty i           newO i    cloneDeep o i               return newO

User · Answer

If you re using it  the Underscore js library has a clone method   var newObject     clone oldObject

User · Answer

With the proposal of the new method Object fromEntries   that is supported on newer versions of some browsers  reference   I want to contribute with the next recursive approach    x000D   x000D  const obj     x000D    key1   key11   key11   key12   key12   key13   key131  22    x000D    key2   key21   key21   key22   key22    x000D    key3   key3   x000D    key4   1 2 3   key   value    x000D    x000D   x000D  const cloneObj    obj    gt  x000D    x000D      if  Object obj      obj  x000D         return obj  x000D      else if  Array isArray obj   x000D         return obj map cloneObj   x000D   x000D      return Object fromEntries Object entries obj  map  x000D            k v     gt    k  cloneObj v    x000D          x000D    x000D   x000D     Clone the original object  x000D  let newObj   cloneObj obj   x000D   x000D     Make changes on the original object  x000D  obj key1 key11    TEST   x000D  obj key3    TEST   x000D  obj key1 key13 key131    TEST   x000D  obj key4 1     TEST   x000D  obj key4 3  key    TEST   x000D   x000D     Display both objects on the console  x000D  console log  Original object     obj   x000D  console log  Cloned object     newObj   x000D   as-console  background-color black  important  color lime   x000D   as-console-wrapper  max-height 100   important  top 0   x000D   x000D   x000D

User · Answer

ES 2017 example   let objectToCopy   someObj  let copyOfObject       Object defineProperties copyOfObject  Object getOwnPropertyDescriptors objectToCopy       copyOfObject will now be the same as objectToCopy

User · Answer

How about merging the keys of the object with its values   function deepClone o        var keys   Object keys o       var values   Object values o        var clone            keys forEach function key  i            clone key    typeof values i      object    Object create values i     values i                return clone      Note  This method doesn t necessarily make shallow copies  but it only copies with the depth of one inner-object  meaning that when you are given something like  a   b   c  null     it will only clone the objects that are directly inside of them  so  deepClone a b  c is technically a reference to a b c  while deepClone a  b is a clone  not a reference

User · Answer

As this question is having lot of attention and answers with reference to inbuilt features such as Object assign or custom code to deep clone  i would like to share some libraries to deep clone    1  esclone  npm install --savedev esclone https   www npmjs com package esclone  Example use in ES6   import esclone from  esclone    const rockysGrandFather       name   Rockys grand father     father   Don t know        const rockysFather       name   Rockys Father     father  rockysGrandFather     const rocky       name   Rocky     father  rockysFather     const rockyClone   esclone rocky     Example use in ES5   var esclone   require  esclone   var foo   new String  abcd   var fooClone   esclone default foo  console log fooClone  console log foo     fooClone    2  deep copy  npm install deep-copy https   www npmjs com package deep-copy  Example   var dcopy   require  deep-copy       deep copy object  var copy   dcopy  a   b    c  5          deep copy array  var copy   dcopy  1  2   a   b  5       3  clone-deep    npm install --save clone-deep https   www npmjs com package clone-deep  Example   var cloneDeep   require  clone-deep     var obj    a   b    var arr    obj    var copy   cloneDeep arr   obj c    d    console log copy       gt    a   b      console log arr

User · Answer

For the people who want to use the JSON parse JSON stringify obj   version  but without losing the Date objects  you can use the second argument of parse method to convert the strings back to Date   x000D   x000D  function clone obj      var regExp      d 4 - d 2 - d 2 T d 2   d 2   d 2    d 3 Z      return JSON parse JSON stringify obj   function k  v        if  typeof v      string   amp  amp  regExp test v         return new Date v      return v             usage  var original      a   1  null  undefined  0   a null   new Date      b       c    return 0         var cloned   clone original   console log cloned  x000D   x000D   x000D

User · Answer

In JavaScript  you can write your deepCopy method like    function deepCopy src      let target   Array isArray src               for  let prop in src        let value   src prop       if value  amp  amp  typeof value      object           target prop    deepCopy value       else         target prop    value             return target

User · Answer

There   s a library  called    clone      that does this quite well  It provides the most complete recursive cloning copying of arbitrary objects that I know of  It also supports circular references  which is not covered by the other answers  yet   You can find it on npm  too  It can be used for the browser as well as Node js   Here is an example on how to use it   Install it with  npm install clone   or package it with Ender   ender build clone         You can also download the source code manually   Then you can use it in your source code   var clone   require  clone     var a     foo    bar   baz           inital value of a var b   clone a                      clone a - gt  b a foo bar    foo                     change a  console log a                          foo    bar   foo      console log b                          foo    bar   baz         Disclaimer  I   m the author of the library

User · Answer

Without touching the prototypical inheritance you may deep lone objects and arrays as follows    x000D   x000D  function objectClone o   x000D    var ot   Array isArray o   x000D    return o     null  amp  amp  typeof o      object    Object keys o  x000D                                                        reduce  r k    gt  o k      null  amp  amp  typeof o k       object     r k    objectClone o k   r  x000D                                                                                                                     r k    o k  r   ot            x000D                                                 o  x000D    x000D  var obj    a  1  b   c  2  d   e  3  f   g  4  h  null      x000D      arr    1 2  3 4  5 6  7      x000D      nil   null  x000D    clobj   objectClone obj   x000D    clarr   objectClone arr   x000D    clnil   objectClone nil   x000D  console log clobj  obj     clobj   x000D  console log clarr  arr     clarr   x000D  console log clnil  nil     clnil   x000D  clarr 2  2  2     seven   x000D  console log arr  clarr   x000D   x000D   x000D

User · Answer

Cloning an Object was always a concern in JS  but it was all about before ES6  I list different ways of copying an object in JavaScript below  imagine you have the Object below and would like to have a deep copy of that   var obj    a 1  b 2  c 3  d 4     There are few ways to copy this object  without changing the origin   1  ES5   Using a simple function to do the copy for you   function deepCopyObj obj        if  null    obj     object     typeof obj  return obj      if  obj instanceof Date            var copy   new Date            copy setTime obj getTime             return copy            if  obj instanceof Array            var copy               for  var i   0  len   obj length  i  lt  len  i                  copy i    cloneSO obj i                      return copy            if  obj instanceof Object            var copy               for  var attr in obj                if  obj hasOwnProperty attr   copy attr    cloneSO obj attr                      return copy            throw new Error  Unable to copy obj this object         2  ES5   using JSON parse and JSON stringify   var  deepCopyObj   JSON parse JSON stringify obj      3  AngularJs    var  deepCopyObj   angular copy obj     4  jQuery    var deepCopyObj   jQuery extend true      obj     5  UnderscoreJs  amp  Loadash    var deepCopyObj     cloneDeep obj     latest version UndescoreJs makes shallow copy   Hope these help

User · Answer

var clone   function         var newObj    this instanceof Array                 for  var i in this            if  this i   amp  amp  typeof this i      object                 newObj i    this i  clone                      else                       newObj i    this i                       return newObj       Object defineProperty  Object prototype   clone    value  clone  enumerable  false

User · Answer

Structured Cloning  The HTML standard includes an internal structured cloning serialization algorithm that can create deep clones of objects  It is still limited to certain built-in types  but in addition to the few types supported by JSON it also supports Dates  RegExps  Maps  Sets  Blobs  FileLists  ImageDatas  sparse Arrays  Typed Arrays  and probably more in the future  It also preserves references within the cloned data  allowing it to support cyclical and recursive structures that would cause errors for JSON   Support in Node js  Experimental   The v8 module in Node js currently  as of Node 11  exposes the structured serialization API directly  but this functionality is still marked as  experimental   and subject to change or removal in future versions  If you re using a compatible version  cloning an object is as simple as   const v8   require  v8     const structuredClone   obj   gt      return v8 deserialize v8 serialize obj         Direct Support in Browsers  Maybe Eventually    Browsers do not currently provide a direct interface for the structured cloning algorithm  but a global structuredClone   function has been discussed in whatwg html 793 on GitHub  As currently proposed  using it for most purposes would be as simple as   const clone   structuredClone original     Unless this is shipped  browsers  structured clone implementations are only exposed indirectly   Asynchronous Workaround  Usable    The lower-overhead way to create a structured clone with existing APIs is to post the data through one port of a MessageChannels  The other port will emit a message event with a structured clone of the attached  data  Unfortunately  listening for these events is necessarily asynchronous  and the synchronous alternatives are less practical   class StructuredCloner     constructor         this pendingClones    new Map        this nextKey    0       const channel   new MessageChannel        this inPort    channel port1      this outPort    channel port2       this outPort  onmessage     data   key  value      gt          const resolve   this pendingClones  get key         resolve value         this pendingClones  delete key              this outPort  start           cloneAsync value        return new Promise resolve   gt          const key   this nextKey           this pendingClones  set key  resolve         this inPort  postMessage  key  value                   const structuredCloneAsync   window structuredCloneAsync       StructuredCloner prototype cloneAsync bind new StructuredCloner     Example Use   const main   async      gt      const original     date  new Date    number  Math random        original self   original     const clone   await structuredCloneAsync original         They re different objects    console assert original     clone     console assert original date     clone date         They re cyclical    console assert original self     original     console assert clone self     clone         They contain equivalent values    console assert original number     clone number     console assert Number original date      Number clone date       console log  Assertions complete         main      Synchronous Workarounds  Awful    There are no good options for creating structured clones synchronously  Here are a couple of impractical hacks instead   history pushState   and history replaceState   both create a structured clone of their first argument  and assign that value to history state  You can use this to create a structured clone of any object like this   const structuredClone   obj   gt      const oldState   history state    history replaceState obj  null     const clonedObj   history state    history replaceState oldState  null     return clonedObj       Example Use    x000D   x000D   use strict   x000D   x000D  const main        gt    x000D    const original     date  new Date    number  Math random      x000D    original self   original  x000D   x000D    const clone   structuredClone original   x000D     x000D       They re different objects  x000D    console assert original     clone   x000D    console assert original date     clone date   x000D   x000D       They re cyclical  x000D    console assert original self     original   x000D    console assert clone self     clone   x000D   x000D       They contain equivalent values  x000D    console assert original number     clone number   x000D    console assert Number original date      Number clone date    x000D     x000D    console log  Assertions complete     x000D     x000D   x000D  const structuredClone   obj   gt    x000D    const oldState   history state  x000D    history replaceState obj  null   x000D    const clonedObj   history state  x000D    history replaceState oldState  null   x000D    return clonedObj  x000D     x000D   x000D  main    x000D   x000D   x000D    Though synchronous  this can be extremely slow  It incurs all of the overhead associated with manipulating the browser history  Calling this method repeatedly can cause Chrome to become temporarily unresponsive   The Notification constructor creates a structured clone of its associated data  It also attempts to display a browser notification to the user  but this will silently fail unless you have requested notification permission  In case you have the permission for other purposes  we ll immediately close the notification we ve created   const structuredClone   obj   gt      const n   new Notification      data  obj  silent  true      n onshow   n close bind n     return n data       Example Use    x000D   x000D   use strict   x000D   x000D  const main        gt    x000D    const original     date  new Date    number  Math random      x000D    original self   original  x000D   x000D    const clone   structuredClone original   x000D     x000D       They re different objects  x000D    console assert original     clone   x000D    console assert original date     clone date   x000D   x000D       They re cyclical  x000D    console assert original self     original   x000D    console assert clone self     clone   x000D   x000D       They contain equivalent values  x000D    console assert original number     clone number   x000D    console assert Number original date      Number clone date    x000D     x000D    console log  Assertions complete     x000D     x000D   x000D  const structuredClone   obj   gt    x000D    const n   new Notification      data  obj  silent  true    x000D    n close    x000D    return n data  x000D     x000D   x000D  main    x000D   x000D   x000D

User · Answer

obj target object  vals source object var setVals   function  obj  vals        if  obj  amp  amp  vals            for  var x in vals                if  vals hasOwnProperty x                     if  obj x   amp  amp  typeof vals x       object                         obj x    setVals obj x   vals x                      else                       obj x    vals x                                                       return obj

User · Answer

function clone obj        var copy          Handle the 3 simple types  and null or undefined     if  null    obj     object     typeof obj  return obj          Handle Date     if  obj instanceof Date            copy   new Date            copy setTime obj getTime             return copy                Handle Array     if  obj instanceof Array            copy               for  var i   0  len   obj length  i  lt  len  i                  copy i    clone obj i                      return copy                Handle Object     if  obj instanceof Object            copy               for  var attr in obj                if  obj hasOwnProperty attr   copy attr    clone obj attr                      return copy             throw new Error  Unable to copy obj  Its type isn t supported         use the following method instead of JSON parse JSON stringify obj    because  it is slower than the following method   How do I correctly clone a JavaScript object

User · Answer

Assuming that you have only variables and not any functions in your object  you can  just use   var newObject   JSON parse JSON stringify oldObject

User · Answer

Just because I didn t see AngularJS mentioned and thought that people might want to know     angular copy also provides a method of deep copying objects and arrays

User · Answer

I use the npm clone library   Apparently it also works in the browser   https   www npmjs com package clone  let a   clone b

User · Answer

What about asynchronous object cloning done by a Promise   async function clone thingy             if thingy instanceof Promise                throw Error  This function cannot clone Promises               return thingy

User · Answer

Cloning an object using today s JavaScript  ECMAScript 2015  formerly known as ECMAScript nbsp 6   var original    a  1       Method 1  New object with original assigned  var copy1   Object assign     original       Method 2  New object with spread operator assignment  var copy2       original     Old browsers may not support ECMAScript 2015  A common solution is to use a JavaScript-to-JavaScript compiler like Babel to output an ECMAScript 5 version of your JavaScript code   As pointed out by  jim-hall  this is only a shallow copy  Properties of properties are copied as a reference  changing one would change the value in the other object instance

User · Answer

I usually use var newObj   JSON parse  JSON stringify oldObje     but  here s a more proper way   var o        var oo   Object create o     o     oo        gt  false   Watch legacy browsers

User · Answer

Crockford suggests  and I prefer  using this function   function object o        function F          F prototype   o      return new F       var newObject   object oldObject     It s terse  works as expected and you don t need a library     EDIT   This is a polyfill for Object create  so you also can use this   var newObject   Object create oldObject     NOTE   If you use some of this  you may have problems with some iteration who use hasOwnProperty  Because  create create new empty object who inherits oldObject  But it is still useful and practical for cloning objects   For exemple if  oldObject a   5   newObject a     is 5   but   oldObject hasOwnProperty a      is true newObject hasOwnProperty a      is false

User · Answer

Lodash has a function that handles that for you like so   var foo    a   a   b   c  d   e   f   g       var bar     cloneDeep foo      bar    a   a   b   c  d   e   f   g        Read the docs here

User · Answer

Single-line ECMAScript 6 solution  special object types like Date Regex not handled     x000D   x000D  const clone    o    gt  x000D    typeof o      object   amp  amp  o     null           only clone objects x000D     Array isArray o                              if cloning an array x000D      o map e   gt  clone e                          clone each of its elements x000D      Object keys o  reduce                       otherwise reduce every key in the object x000D         r  k    gt   r k    clone o k    r          and save its cloned value into a new object x000D        x000D        x000D    o                                             return non-objects as is x000D   x000D  var x     x000D    nested    x000D      name   test  x000D      x000D     x000D   x000D  var y   clone x   x000D   x000D  console log x nested     y nested   x000D   x000D   x000D

User · Answer

There are so many ways to achieve this  but if you want to do this without any library  you can use the following   const cloneObject    oldObject    gt      let newObject   oldObject    if  oldObject  amp  amp  typeof oldObject      object         if Array isArray oldObject           newObject             else if  Object prototype toString call oldObject        object Date    amp  amp   isNaN oldObject           newObject   new Date oldObject getTime           else         newObject             for  let i in oldObject            newObject i    cloneObject oldObject i                         return newObject      Let me know what you think

User · Answer

I think that this is the best solution  if you want to generalize your object cloning algorithm  It can be used with or without jQuery  although I recommend leaving jQuery s extend method out if you want you the cloned object to have the same  class  as the original one   function clone obj       if typeof obj      function    it s a simple function         return obj        of it s not an object  but could be an array   even if in javascript arrays are objects      if typeof obj       object     obj constructor toString   indexOf  Array    -1          if JSON    undefined   if we have the JSON obj             try                  return JSON parse JSON stringify obj                 catch err                   return JSON parse     JSON stringify obj                              else             try                  return eval uneval obj                 catch err                   return eval     uneval obj                             I used to rely on jQuery for this  but the  extend  function returns       an object similar to the one cloned        but that was not an instance  instanceof  of the cloned class            if jQuery    undefined   if we use the jQuery plugin         return jQuery extend true    obj       else  we recursivley clone the object            return  function  clone obj           if obj    null    typeof obj      object               return obj          function temp                temp prototype   obj          var F   new temp          for var key in obj              F key    clone obj key            return F         obj

User · Answer

I have two good answers depending on whether your objective is to clone a  plain old JavaScript object  or not   Let s also assume that your intention is to create a complete clone with no prototype references back to the source object  If you re not interested in a complete clone  then you can use many of the Object clone   routines provided in some of the other answers  Crockford s pattern    For plain old JavaScript objects  a tried and true good way to clone an object in modern runtimes is quite simply   var clone   JSON parse JSON stringify obj      Note that the source object must be a pure JSON object  This is to say  all of its nested properties must be scalars  like boolean  string  array  object  etc   Any functions or special objects like RegExp or Date will not be cloned   Is it efficient  Heck yes  We ve tried all kinds of cloning methods and this works best  I m sure some ninja could conjure up a faster method  But I suspect we re talking about marginal gains   This approach is just simple and easy to implement  Wrap it into a convenience function and if you really need to squeeze out some gain  go for at a later time   Now  for non-plain JavaScript objects  there isn t a really simple answer   In fact  there can t be because of the dynamic nature of JavaScript functions and inner object state  Deep cloning a JSON structure with functions inside requires you recreate those functions and their inner context  And JavaScript simply doesn t have a standardized way of doing that   The correct way to do this  once again  is via a convenience method that you declare and reuse within your code  The convenience method can be endowed with some understanding of your own objects so you can make sure to properly recreate the graph within the new object   We re written our own  but the best general approach I ve seen is covered here   http   davidwalsh name javascript-clone  This is the right idea  The author  David Walsh  has commented out the cloning of generalized functions  This is something you might choose to do  depending on your use case   The main idea is that you need to special handle the instantiation of your functions  or prototypal classes  so to speak  on a per-type basis  Here  he s provided a few examples for RegExp and Date   Not only is this code brief  but it s also very readable  It s pretty easy to extend   Is this efficient  Heck yes  Given that the goal is to produce a true deep-copy clone  then you re going to have to walk the members of the source object graph  With this approach  you can tweak exactly which child members to treat and how to manually handle custom types   So there you go  Two approaches  Both are efficient in my view

User · Answer

This is the fastest method I have created that doesn t use the prototype  so it will maintain hasOwnProperty in the new object   The solution is to iterate the top level properties of the original object  make two copies  delete each property from the original and then reset the original object and return the new copy  It only has to iterate as many times as top level properties  This saves all the if conditions to check if each property is a function  object  string  etc   and doesn t have to iterate each descendant property   The only drawback is that the original object must be supplied with its original created namespace  in order to reset it   copyDeleteAndReset function namespace strObjName       var obj   namespace strObjName       objNew      objOrig           for i in obj           if obj hasOwnProperty i                objNew i    objOrig i    obj i               delete obj i                       namespace strObjName    objOrig      return objNew     var namespace       namespace objOrig          0            innerObj  a 0 b 1 c 2           var objNew   copyDeleteAndReset namespace  objOrig    objNew  0      NEW VALUE    console log objNew  0         NEW VALUE   console log namespace objOrig  0        innerObj  a 0 b 1 c 2

User · Answer

Looking through this long list of answers nearly all the solutions have been covered except one that I am aware of  This is the list of VANILLA JS ways of deep cloning an object    JSON parse JSON stringify  obj      Through history state with pushState or replaceState Web Notifications API but this has the downside of asking the user for permissions  Doing your own recursive loop through the object to copy each level  The answer I didn t see -  Using ServiceWorkers  The messages  objects  passed back and forth between the page and the ServiceWorker script will be deep clones of any object

User · Answer

When your object is nested and it contains data object  other structured object or some property object  etc then using JSON parse JSON stringify object   or Object assign     obj  or   extend true      obj  will not work  In that case use lodash  It is simple and easy    var obj    a  25  b   a  1  b  2   c  new Date    d  anotherNestedObject    var A     cloneDeep obj     Now A will be your new cloned of obj without any references

User · Answer

If there wasn t any builtin one  you could try   function clone obj        if  obj     null    typeof  obj       object      isActiveClone  in obj          return obj       if  obj instanceof Date          var temp   new obj constructor      or new Date obj       else         var temp   obj constructor         for  var key in obj            if  Object prototype hasOwnProperty call obj  key                 obj  isActiveClone     null              temp key    clone obj key                delete obj  isActiveClone                        return temp

User · Answer

There are a lot of answers  but none of them gave the desired effect I needed   I wanted to utilize the power of jQuery s deep copy    However  when it runs into an array  it simply copies the reference to the array and deep copies the items in it   To get around this  I made a nice little recursive function that will create a new array automatically      It even checks for kendo data ObservableArray if you want it to   Though  make sure you make sure you call kendo observable newItem  if you want the Arrays to be observable again     So  to fully copy an existing item  you just do this   var newItem   jQuery extend true      oldItem   createNewArrays newItem     function createNewArrays obj        for  var prop in obj            if   kendo    null  amp  amp  obj prop  instanceof kendo data ObservableArray     obj prop  instanceof Array                var copy                     each obj prop   function  i  item                    var newChild     extend true      item                   createNewArrays newChild                   copy push newChild                               obj prop    copy

User · Answer

Deep copying objects in JavaScript  I think the best and the simplest   1  Using JSON parse JSON stringify object     var obj        a  1    b         c  2       var newObj   JSON parse JSON stringify obj    obj b c   20  console log obj        a  1  b    c  20     console log newObj        a  1  b    c  2        2 Using created method  function cloneObject obj        var clone           for var i in obj            if obj i     null  amp  amp   typeof obj i     object               clone i    cloneObject obj i            else             clone i    obj i             return clone     var obj        a  1    b         c  2       var newObj   cloneObject obj   obj b c   20   console log obj        a  1  b    c  20     console log newObj        a  1  b    c  2        3  Using Lo-Dash s   cloneDeep link lodash  var obj        a  1    b         c  2        var newObj     cloneDeep obj   obj b c   20  console log obj        a  1  b    c  20     console log newObj        a  1  b    c  2        4  Using Object assign   method  var obj        a  1    b  2    var newObj     clone obj   obj b   20  console log obj        a  1  b  20   console log newObj        a  1  b  2       BUT WRONG WHEN  var obj        a  1    b         c  2        var newObj   Object assign     obj   obj b c   20  console log obj        a  1  b    c  20     console log newObj        a  1  b    c  20     -- gt  WRONG    Note  Properties on the prototype chain and non-enumerable properties cannot be copied    5 Using Underscore js   clone link Underscore js  var obj        a  1    b  2    var newObj     clone obj   obj b   20  console log obj        a  1  b  20   console log newObj        a  1  b  2       BUT WRONG WHEN  var obj        a  1    b         c  2        var newObj     cloneDeep obj   obj b c   20  console log obj        a  1  b    c  20     console log newObj        a  1  b    c  20     -- gt  WRONG     Create a shallow-copied clone of the provided plain object  Any nested objects or arrays will be copied by reference  not duplicated     JSBEN CH Performance Benchmarking Playground 1 3 http   jsben ch KVQLd

User · Answer

Deep copy by performance  Ranked from best to worst   Reassignment      string arrays  number arrays - only  Slice  string arrays  number arrays - only  Concatenation  string arrays  number arrays - only  Custom function  for-loop or recursive copy jQuery s   extend JSON parse  string arrays  number arrays  object arrays - only  Underscore js s   clone  string arrays  number arrays - only  Lo-Dash s   cloneDeep   Deep copy an array of strings or numbers  one level - no reference pointers    When an array contains numbers and strings - functions like  slice     concat     splice    the assignment operator      and Underscore js s clone function  will make a deep copy of the array s elements   Where reassignment has the fastest performance   var arr1     a    b    c    var arr2   arr1  arr1     a    b    c      And  slice   has better performance than  concat    http   jsperf com duplicate-array-slice-vs-concat 3  var arr1     a    b    c        Becomes arr1     a    b    c   var arr2a   arr1 slice 0        Becomes arr2a     a    b    c   - deep copy var arr2b   arr1 concat         Becomes arr2b     a    b    c   - deep copy   Deep copy an array of objects  two or more levels - reference pointers    var arr1     object  a     object  b       Write a custom function  has faster performance than   extend   or JSON parse    function copy o       var out  v  key     out   Array isArray o                for  key in o           v   o key          out key     typeof v      object   amp  amp  v     null    copy v    v          return out     copy arr1     Use third-party utility functions     extend true      arr1      Jquery Extend JSON parse arr1     cloneDeep arr1      Lo-dash   Where jQuery s   extend has better performance    http   jsperf com js-deep-copy 2 http   jsperf com jquery-extend-vs-json-parse 2

User · Answer

In my experience  a recursive version vastly outperforms JSON parse JSON stringify obj    Here is a modernized recursive deep object copy function which can fit on a single line   function deepCopy obj      return Object keys obj  reduce  v  d    gt  Object assign v         d    obj d  constructor     Object    deepCopy obj d     obj d                 This is performing around 40 times faster than the JSON parse    method

User · Answer

As recursion is just too expensive for JavaScript  and most answers I have found are using recursion  while JSON approach will skip the non-JSON-convertible parts  Function  etc    So I did a little research and found this trampoline technique to avoid it  Here s the code         Trampoline to avoid recursion in JavaScript  see         http   www integralist co uk posts js-recursion html     function trampoline         var func   arguments 0       var args           for  var i   1  i  lt  arguments length  i              args i - 1    arguments i              var currentBatch   func apply this  args       var nextBatch            while  currentBatch  amp  amp  currentBatch length  gt  0            currentBatch forEach function eachFunc                var ret   eachFunc                if  ret  amp  amp  ret length  gt  0                    nextBatch   nextBatch concat ret                                      currentBatch   nextBatch          nextBatch                        Deep clone an object using the trampoline technique          param target  Object  Object to clone      return  Object  Cloned object      function clone target        if  typeof target      object             return target            if  target    null    Object keys target  length    0            return target             function  clone b  a            var nextBatch               for  var key in b                if  typeof b key       object   amp  amp  b key      null                    if  b key  instanceof Array                        a key                                          else                       a key                                          nextBatch push  clone bind null  b key   a key                               else                   a key    b key                                   return nextBatch              var ret   target instanceof Array                 trampoline bind null   clone   target  ret       return ret       Also see this gist     https   gist github com SeanOceanHu 7594cafbfab682f790eb

User · Answer

Use Object create   to get the prototype and support for instanceof  and use a for   loop to get enumerable keys   function cloneObject source        var key value      var clone   Object create source        for  key in source            if  source hasOwnProperty key      true                value   source key                if  value   null  amp  amp  typeof value    object                     clone key    cloneObject value                 else                   clone key    value                                     return clone

User · Answer

Object assign    sourceObj  only clones the object if their property is not having reference type key  ex   obj  a  lol  b   yes   no   maybe    clonedObj   Object assign    obj    clonedObj b push  skip     changes will reflected to the actual obj as well because of its reference type  obj b   will also console   gt  yes no maybe skip   So for the deep cloning is not possible to achieve in this way   The best solution that works is  var obj   Json stringify yourSourceObj  var cloned   Json parse obj

User · Answer

My scenario was a bit different  I had an object with nested objects as well as functions  Therefore  Object assign   and JSON stringify   were not solutions to my problem  Using third-party libraries was not an option for me neither   Hence  I decided to make a simple function to use built-in methods to copy an object with its literal properties  its nested objects  and functions   let deepCopy    target  source    gt        Object assign target  source          check if there s any nested objects     Object keys source  forEach  prop    gt                            assign function copies functions and             literals  int  strings  etc                 except for objects and arrays  so                       if  typeof source prop        object                    check if the item is  in fact  an array             if  Array isArray source prop                         clear the copied referenece of nested array                 target prop    Array                       iterate array s item and copy over                 source prop  forEach  item  index    gt                           array s items could be objects too                      if  typeof item       object                                clear the copied referenece of nested objects                         target prop  index    Object                               and re do the process for nested objects                         deepCopy target prop  index   item                         else                           target prop  push item                                                            otherwise  treat it as an object               else                      clear the copied referenece of nested objects                 target prop    Object                       and re do the process for nested objects                 deepCopy target prop   source prop                                         Here s a test code   let a         name   Human        func       gt            console log  Hi                 prop            age  21           info                hasShirt  true               hasHat  false                      mark   89  92    exam   1  2  3         let b   Object     deepCopy b  a    a name    Alien   a func        gt    console log  Wassup        a prop age   1024  a prop info hasShirt   false  a mark 0    87  a mark 1    91  a mark 2  exam    4  5  6    console log a      updated props console log b     For efficiency-related concerns  I believe this is the simplest and most efficient solution to the problem I had  I would appreciate any comments on this algorithm that could make it more efficient

User · Answer

This is a solution with recursion    x000D   x000D  obj     x000D    a    b    c    d    1    2          x000D    e   Saeid  x000D    x000D  const Clone   function  obj    x000D     x000D    const container   Array isArray obj            x000D    const keys    Object keys obj  x000D      x000D    for  let i   0  i  lt  keys length  i      x000D      const key   keys i  x000D      if typeof obj key      object     x000D        container key    Clone obj key   x000D        x000D      else x000D        container key    obj key  slice   x000D      x000D     x000D    return container x000D    x000D   console log Clone obj   x000D   x000D   x000D

User · Answer

For a shallow copy there is a great  simple method introduced in ECMAScript2018 standard  It involves the use of Spread Operator    let obj    a    foo   b  bar    c 10   d true   e  1 2 3      let objClone        obj      I have tested it in Chrome browser  both objects are stored in different locations  so changing immediate child values in either will not change the other   Though  in the example  changing a value in e will effect both copies   This technique is very simple and straight forward  I consider this a true Best Practice for this question once and for all

User · Answer

This is what I m using   function cloneObject obj        var clone           for var i in obj            if typeof obj i     object   amp  amp  obj i     null              clone i    cloneObject obj i            else             clone i    obj i             return clone

User · Answer

For future reference  the current draft of ECMAScript 6 introduces Object assign as a way of cloning objects  Example code would be   var obj1     a  true  b  1    var obj2   Object assign obj1   console log obj2        a  true  b  1     At the time of writing support is limited to Firefox 34 in browsers so it   s not usable in production code just yet  unless you   re writing a Firefox extension of course

User · Answer

x000D   x000D  class Handler   x000D    static deepCopy  obj    x000D      if  Object prototype toString call obj        object Array      x000D        const result       x000D         x000D        for  let i   0  len   obj length  i  lt  len  i      x000D          result i    Handler deepCopy obj i    x000D          x000D        return result  x000D        else if  Object prototype toString call obj        object Object      x000D        const result       x000D        for  let prop in obj    x000D          result prop    Handler deepCopy obj prop    x000D          x000D        return result  x000D        x000D      return obj  x000D      x000D    x000D   x000D   x000D

User · Answer

Native deep cloning It s called  quot structured cloning quot   works experimentally in Node 11 and later  and hopefully will land in browsers  See this answer for more details  Fast cloning with data loss - JSON parse stringify If you do not use Dates  functions  undefined  Infinity  RegExps  Maps  Sets  Blobs  FileLists  ImageDatas  sparse Arrays  Typed Arrays or other complex types within your object  a very simple one liner to deep clone an object is  JSON parse JSON stringify object    x000D   x000D  const a       string   string     number  123    bool  false    nul  null    date  new Date        stringified   undef  undefined      lost   inf  Infinity      forced to  null    re            lost   console log a   console log typeof a date       Date object const clone   JSON parse JSON stringify a    console log clone   console log typeof clone date       result of  toISOString   x000D   x000D   x000D   See Corban s answer for benchmarks  Reliable cloning using a library Since cloning objects is not trivial  complex types  circular references  function etc    most major libraries provide function to clone objects  Don t reinvent the wheel - if you re already using a library  check if it has an object cloning function  For example   lodash - cloneDeep  can be imported separately via the lodash clonedeep module and is probably your best choice if you re not already using a library that provides a deep cloning function AngularJS - angular copy jQuery - jQuery extend true       oldObject    clone   only clones DOM elements  ES6  shallow copy  For completeness  note that ES6 offers two shallow copy mechanisms  Object assign   and the spread syntax  which copies values of all enumerable own properties from one object to another  For example  var A1    a   quot 2 quot    var A2   Object assign     A1   var A3       A1       Spread Syntax

User · Answer

Here s a version of ConroyP s answer above that works even if the constructor has required parameters     If Object create isn t already defined  we just do the simple shim    without the second argument  since that s all we need here var object create   Object create  if  typeof object create      function         object create   function o            function F              F prototype   o          return new F              function deepCopy obj        if obj    null    typeof obj       object            return obj              make sure the returned object has the same prototype as the original     var ret   object create obj constructor prototype       for var key in obj           ret key    deepCopy obj key              return ret      This function is also available in my simpleoo library   Edit   Here s a more robust version  thanks to Justin McCandless this now supports cyclic references as well           Deep copy an object  make copies of all its object properties  sub-properties  etc      An improved version of http   keithdevens com weblog archive 2007 Jun 07 javascript clone    that doesn t break if the constructor has required parameters        It also borrows some code from http   stackoverflow com a 11621004 560114      function deepCopy src     INTERNAL     visited   copiesVisited        if src     null    typeof src       object            return src               Honor native custom clone methods     if typeof src clone     function            return src clone true                Special cases        Date     if src instanceof Date           return new Date src getTime                 RegExp     if src instanceof RegExp           return new RegExp src               DOM Element     if src nodeType  amp  amp  typeof src cloneNode     function            return src cloneNode true                 Initialize the visited objects arrays if needed         This is used to detect cyclic references      if   visited     undefined            visited                copiesVisited                     Check if this object has already been visited     var i  len    visited length      for  i   0  i  lt  len  i                 If so  get the copy we already made         if  src      visited i                 return  copiesVisited i                          Array     if  Object prototype toString call src       object Array                   slice   by itself would soft clone         var ret   src slice               add it to the visited array          visited push src            copiesVisited push ret            var i   ret length          while  i--                ret i    deepCopy ret i    visited   copiesVisited                     return ret               If we ve reached here  we have a regular object        make sure the returned object has the same prototype as the original     var proto    Object getPrototypeOf   Object getPrototypeOf src   src   proto         if   proto            proto   src constructor prototype    this line would probably only be reached by very old browsers            var dest   object create proto          add this object to the visited array      visited push src        copiesVisited push dest        for  var key in src              Note  this does NOT preserve ES5 property attributes like  writable    enumerable   etc            For an example of how this could be modified to do so  see the singleMixin   function         dest key    deepCopy src key    visited   copiesVisited             return dest       If Object create isn t already defined  we just do the simple shim    without the second argument  since that s all we need here var object create   Object create  if  typeof object create      function         object create   function o            function F              F prototype   o          return new F

User · Answer

if you find yourself doing this type of thing regular   eg- creating undo redo functionality   it might be worth looking into Immutable js  const map1   Immutable fromJS    a  1  b  2  c    d  3        const map2   map1 setIn     c    d     50     console log      map1 getIn     c    d        vs    map2 getIn     c    d                3 vs 50    https   codepen io anon pen OBpqNE editors 1111

User · Answer

Shallow copy one-liner  ECMAScript 5th edition    var origin     foo         var copy   Object keys origin  reduce function c k  c k  origin k  return c         console log origin  copy   console log origin    copy      false console log origin foo    copy foo      true   And shallow copy one-liner  ECMAScript 6th edition  2015    var origin     foo         var copy   Object assign     origin    console log origin  copy   console log origin    copy      false console log origin foo    copy foo      true

User · Answer

I am late to answer this question  but I have an another way of cloning the object  function cloneObject obj        if  obj     null    typeof obj       object           return obj      var temp   obj constructor       changed     for  var key in obj            if  Object prototype hasOwnProperty call obj  key                 obj  isActiveClone     null              temp key    cloneObject obj key                delete obj  isActiveClone                        return temp     var b   cloneObject   quot a quot  1  quot b quot  2         calling  which is much better and faster then  var a     quot a quot  1  quot b quot  2   var b   JSON parse JSON stringify a       and var a     quot a quot  1  quot b quot  2       Deep copy var newObject   jQuery extend true      a    I have bench-marked the code and you can test the results here  and sharing the results   References  https   developer mozilla org en-US docs Web JavaScript Reference Global Objects Object hasOwnProperty

User · Answer

The following creates two instances of the same object  I found it and am using it currently  It s simple and easy to use   var objToCreate   JSON parse JSON stringify cloneThis

User · Answer

This is my version of object cloner  This is a stand-alone version of the jQuery method  with only few tweaks and adjustments  Check out the fiddle  I ve used a lot of jQuery until the day I realized that I d use only this function most of the time x x   The usage is the same as described into the jQuery API    Non-deep clone  extend object dest  object source   Deep clone  extend true  object dest  object source     One extra function is used to define if object is proper to be cloned          This is a quasi clone of jQuery s extend   function     by Romain WEEGER for wJs library - www wexample com     returns            function extend            Make a copy of arguments to avoid JavaScript inspector hints      var to add  name  copy is array  clone          The target object who receive parameters        form other objects      target   arguments 0                 Index of first argument to mix to target      i   1          Mix target with all function arguments      length   arguments length          Define if we merge object recursively      deep   false          Handle a deep copy situation      if  typeof target      boolean             deep   target              Skip the boolean and the target          target   arguments  i                      Use next object as first added          i                  Handle case when target is a string or something  possible in deep copy      if  typeof target      object   amp  amp  typeof target      function             target                     Loop trough arguments      for  false  i  lt  length  i    1                Only deal with non-null undefined values         if   to add   arguments  i        null                    Extend the base object              for  name in to add                        We do not wrap for loop into hasOwnProperty                     to access to all values of object                     Prevent never-ending loop                  if  target     to add name                         continue                                        Recurse if we re merging plain objects or arrays                  if  deep  amp  amp  to add name   amp  amp   is plain object to add name       copy is array   Array isArray to add name                            if  copy is array                            copy is array   false                          clone   target name   amp  amp  Array isArray target name     target name                                                  else                           clone   target name   amp  amp  is plain object target name     target name                                                      Never move original objects  clone them                      target name    extend deep  clone  to add name                                          Don t bring in undefined values                  else if  to add name      undefined                        target name    to add name                                                       return target            Check to see if an object is a plain object     created using      or  new Object       Forked from jQuery      param obj     returns  boolean      function is plain object obj           Not plain objects         - Any object or value whose internal   Class   property is not   object Object          - DOM nodes        - window     if  obj     null    typeof obj      object     obj nodeType     obj     null  amp  amp  obj     obj window             return false               Support  Firefox  lt 20        The try catch suppresses exceptions thrown when attempting to access        the  constructor  property of certain host objects  i e   window location         https   bugzilla mozilla org show bug cgi id 814622     try           if  obj constructor  amp  amp   this hasOwnProperty call obj constructor prototype   isPrototypeOf                  return false                      catch  e            return false                If the function hasn t returned already  we re confident that         obj  is a plain object  created by    or constructed with new Object     return true

User · Answer

Checkout this benchmark  http   jsben ch   bWfk9  In my previous tests where speed was a main concern I found   JSON parse JSON stringify obj     to be the slowest way to deep clone an object  it is slower than jQuery extend with deep flag set true by 10-20     jQuery extend is pretty fast when the deep flag is set to false  shallow clone   It is a good option  because it includes some extra logic for type validation and doesn t copy over undefined properties  etc   but this will also slow you down a little   If you know the structure of the objects you are trying to clone or can avoid deep nested arrays you can write a simple for  var i in obj  loop to clone your object while checking hasOwnProperty and it will be much much faster than jQuery   Lastly if you are attempting to clone a known object structure in a hot loop you can get MUCH MUCH MORE PERFORMANCE by simply in-lining the clone procedure and manually constructing the object   JavaScript trace engines suck at optimizing for  in loops and checking hasOwnProperty will slow you down as well  Manual clone when speed is an absolute must   var clonedObject       knownProp  obj knownProp           Beware using the JSON parse JSON stringify obj   method on Date objects - JSON stringify new Date    returns a string representation of the date in ISO format  which JSON parse   doesn t convert back to a Date object  See this answer for more details   Additionally  please note that  in Chrome 65 at least  native cloning is not the way to go  According to JSPerf  performing native cloning by creating a new function is nearly 800x slower than using JSON stringify which is incredibly fast all the way across the board   Update for ES6  If you are using Javascript ES6 try this native method for cloning or shallow copy   Object assign     obj

User · Answer

This is my solution without using any library or native javascript function   function deepClone obj      if  typeof obj      object         return obj      else       let newObj         typeof obj      object   amp  amp  obj length     undefined                for  let key in obj          if  key            newObj key    deepClone obj key                      return newObj

User · Answer

Here is a comprehensive clone   method that can clone any JavaScript object  It handles almost all the cases   function clone src  deep         var toString   Object prototype toString      if   src  amp  amp  typeof src     object                Any non-object  Boolean  String  Number   null  undefined  NaN         return src                Honor native custom clone methods     if  src clone  amp  amp  toString call src clone       object Function              return src clone deep                 DOM elements     if  src nodeType  amp  amp  toString call src cloneNode       object Function              return src cloneNode deep                 Date     if  toString call src       object Date              return new Date src getTime                   RegExp     if  toString call src       object RegExp              return new RegExp src                 Function     if  toString call src       object Function                 Wrap in another method to make sure    is not true            Note  Huge performance issue due to closures  comment this            return  function                src apply this  arguments                          var ret  index        Array     if  toString call src       object Array                   slice 0  would soft clone         ret   src slice            if  deep                index   ret length              while  index--                    ret index    clone ret index   true                                       Object     else           ret   src constructor   new src constructor                 for  var prop in src                ret prop    deep                   clone src prop   true                    src prop                       return ret

[javascript] What is the most efficient way to deep clone an object in JavaScript?

Examples related to javascript

Examples related to object

Examples related to clone