Benchmark: JSON.stringify vs structuredClone vs simple deepCopyObject 4

Script Preparation code:

var deepCopyObject = (inObject) => {
  if (inObject instanceof Date) return inObject

  if (inObject instanceof Set) return new Set(inObject)

  if (inObject instanceof Map) return new Map(inObject)

  if (typeof inObject !== 'object' || inObject === null) {
    return inObject // Return the value if inObject is not an object
  }

  // Create an array or object to hold the values
  const outObject = Array.isArray(inObject) ? [] : {}

  Object.keys(inObject).forEach((key) => {
    const value = inObject[key]

    // Recursively (deep) copy for nested objects, including arrays
    outObject[key] = typeof value === 'object' && value !== null ? deepCopyObject(value) : value
  })

  return outObject
}

function deepCopyObjectSimple(inObject) {
  if (typeof inObject !== 'object' || inObject === null) {
    return inObject;
  }

  const outObject = Array.isArray(inObject) ? [] : {};

  for (const key in inObject) {
    const value = inObject[key];
    outObject[key] = (typeof value === 'object' && value !== null) ? deepCopyObjectSimple(value) : value;
  }

  return outObject;
}

var isArray = Array.isArray;

function copy(obj) {
  if (!obj) return obj;
  if (isArray(obj)) {
    var arr = [];
    var length = obj.length;
    for (var i = 0; i < length; i++) arr.push(copy(obj[i]))
    return arr;
  } else if (typeof obj === 'object') {
    var keys = Object.keys(obj);
    var length = keys.length;
    var newObject = {};
    for (var i = 0; i < length; i++) {
      var key = keys[i];
      newObject[key] = copy(obj[key]);
    }
    return newObject;
  }
  return obj;
}

var objectKeys = Object.keys;

function copyv2(val) {
  if (!val) return val;
  if (isArray(val)) {
    var arr = [];
    var length = val.length;
    for (var i = 0; i < length; i++) arr.push(copy(val[i]))
    return arr;
  } else if (typeof val === 'object') {
    var keys = objectKeys(val);
    var newObject = {};
    for (var i = keys.length - 1; i > -1; i--) {
      var key = keys[i];
      newObject[key] = copy(val[key]);
    }
    return newObject;
  }
  return val;
}


function cloneRegExp(re) {
  const regexMatch = /^\/(.*)\/([gimyu]*)$/.exec(re.toString());
  return new RegExp(regexMatch[1], regexMatch[2]);
}

function clone(arg) {
  if (typeof arg !== 'object') {
    return arg;
  }
  if (arg === null) {
    return null;
  }
  if (Array.isArray(arg)) {
    return arg.map(clone);
  }
  const cloned = {};
  for (const name in arg) {
    if (Object.prototype.hasOwnProperty.call(arg, name)) {
      (cloned)[name] = clone(
        (arg)[name],
      );
    }
  }
  return cloned;
}


function deepCopyObjectIterative(inObject) {
  if (typeof inObject !== 'object' || inObject === null) {
    return inObject;
  }

  const stack = [{ source: inObject, target: Array.isArray(inObject) ? [] : {} }];
  const root = stack[0].target;

  while (stack.length > 0) {
    const { source, target } = stack.pop();

    for (const key in source) {
      const value = source[key];
      if (typeof value === 'object' && value !== null) {
        target[key] = Array.isArray(value) ? [] : {};
        stack.push({ source: value, target: target[key] });
      } else {
        target[key] = value;
      }
    }
  }

  return root;
}

var MyObject = {
  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...'
  }
};

var myCopy = null;

Tests:

JSON.stringify
myCopy = JSON.parse(JSON.stringify(MyObject));
structuredClone
myCopy = structuredClone(MyObject);
deepCopyObject
myCopy = deepCopyObject(MyObject);
deepCopyObjectSimple
myCopy = deepCopyObjectSimple(MyObject);
deepCopyObjectIterative
myCopy = deepCopyObjectIterative(MyObject);
copy
myCopy = copy(MyObject);
clone
myCopy = clone(MyObject);
copyv2
myCopy = copyv2(MyObject);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JSON.stringify
structuredClone
deepCopyObject
deepCopyObjectSimple
deepCopyObjectIterative
copy
clone
copyv2

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's dive into the benchmark results.

It appears that there are six test cases:

1. `deepCopyObjectIterative`
2. `deepCopyObjectSimple`
3. `copyv2`
4. `JSON.stringify`
5. `copy`
6. `clone`

The results show that the execution per second for each test case varies widely, with some tests performing much faster than others.

Here are some observations and insights based on these results:

* **`deepCopyObjectIterative`**: This test performs poorly compared to other methods, suggesting that the iterative approach may not be efficient.
* **`deepCopyObjectSimple`**: This test seems to perform relatively well, indicating that a simple implementation may be sufficient for this task.
* **`copyv2`**: This test performs reasonably well, but its performance is not as good as some of the other tests.
* **`JSON.stringify`**: This test has one of the fastest execution rates, suggesting that serializing and deserializing JSON can be an efficient way to copy objects.
* **`copy`**: This test has a relatively slow execution rate compared to others, indicating that a simple copying method may not be the most efficient approach.
* **`clone`**: This test performs similarly well to `deepCopyObjectSimple`, suggesting that cloning objects may have similar performance characteristics.

Based on these results, it seems that the `structuredClone` method (not listed in the original table) might be the most efficient way to copy complex objects. If you're working with complex objects and need high-performance copying, exploring this method might be worth considering.

However, without more information about your specific use case and requirements, it's difficult to provide a definitive answer.

Latest run results:

Run details: (Test run date: 4 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
JSON.stringify	1503725.2 Ops/sec
structuredClone	823242.8 Ops/sec
deepCopyObject	1305797.4 Ops/sec
deepCopyObjectSimple	3477312.8 Ops/sec
deepCopyObjectIterative	3619534.8 Ops/sec
copy	1333664.8 Ops/sec
clone	1304332.2 Ops/sec
copyv2	1526770.4 Ops/sec

Related benchmarks:

JSON.stringify vs structuredClone vs simple deepCopyObject 4 (version: 0)

JSON.stringify vs structuredClone vs simple deepCopyObject 4

Comparing performance of: JSON.stringify vs structuredClone vs deepCopyObject vs deepCopyObjectSimple vs deepCopyObjectIterative vs copy vs clone vs copyv2

Created: 4 months ago by: Guest

Jump to the latest result

JSON.stringify

structuredClone

deepCopyObject

deepCopyObjectSimple

deepCopyObjectIterative

copy

clone

copyv2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):