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

  1. Home
  2. javascript
  3. What is the most efficient way to deep clone an object in JavaScript?

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.

First answer

2019-June note: This was originally a reply to another answer, not a proper response to this question. No idea why it was picked as the right answer. But since the upvotes snowballed and it’s by far the #1 answer to this question, it will summarize the solutions as a wiki answer.

Native deep cloning

It’s called “structured cloning”, 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:


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(typeof a.date);  // Date object
const clone = JSON.parse(JSON.stringify(a));
console.log(typeof clone.date);  // result of .toISOString()

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,


For completeness, note that ES6 offers two shallow copy mechanisms: Object.assign() and the spread operator.

Second answer

Checkout this benchmark: http://jsben.ch/#/bWfk9

In my previous tests where speed was a main concern I found


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 cloned

Third answer

Spread the love

Related articles

Comments are closed.