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](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/uneval).  

 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.

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](https://api.jquery.com/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](https://stackoverflow.com/questions/11491938/issues-with-date-when-using-json-stringify-and-json-parse/11491993#11491993).

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](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)**

If you are using Javascript ES6 try this native method for cloning or shallow copy.

```
Object.assign({}, obj);

```
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);

```