Benchmark: Lodash cloneDeep vs JSON Clone with huge array of objects

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var MyObject = [];
for (i = 0; i < 500000; i++) {
 MyObject.push({
  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:

Lodash cloneDeep
myCopy = _.cloneDeep(MyObject);
Json clone
myCopy = JSON.parse(JSON.stringify(MyObject));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Json clone

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**What is being tested?**

The provided JSON represents two benchmark cases: `Lodash cloneDeep` and `JSON Clone with huge array of objects`. The goal is to measure the performance difference between using Lodash's `cloneDeep()` function and the built-in `JSON.parse(JSON.stringify())` method when cloning a large array of deeply nested objects.

**Options being compared**

There are two options being compared:

1. **Lodash cloneDeep**: This option uses the `_.cloneDeep()` function from the Lodash library to create a deep copy of the input object.
2. **JSON Clone with huge array of objects**: This option uses the built-in `JSON.parse(JSON.stringify())` method to create a deep copy of the input object.

**Pros and Cons**

* **Lodash cloneDeep**:
	+ Pros: Generally considered more robust and efficient, as it handles complex data structures like circular references and arrays with nested objects.
	+ Cons: Requires including an external library (Lodash), which might add overhead to the benchmark.
* **JSON Clone with huge array of objects**:
	+ Pros: Lightweight and easy to implement, as it only relies on built-in JavaScript functions.
	+ Cons: May not handle complex data structures like circular references or arrays with nested objects correctly.

**Other considerations**

* The benchmark is designed to test the performance difference between these two methods in a scenario where a large array of deeply nested objects needs to be cloned. This scenario is representative of many real-world use cases, such as serializing and deserializing data.
* The `MyObject` constructor is used to create a large array of objects with complex structures, which helps to isolate the benchmark and prevent external factors from affecting the results.

**Library used (Lodash)**

Lodash is a popular JavaScript library that provides a set of functional programming helpers, including `cloneDeep()`. It's widely used in many applications for its concise and expressive code. In this benchmark, Lodash is used to create a deep copy of the input object, which helps to ensure that the cloned data structure is identical to the original.

**Special JS feature or syntax**

There doesn't appear to be any special JavaScript features or syntax being tested in this benchmark. However, it's worth noting that the `JSON.parse(JSON.stringify())` method has some quirks and limitations when dealing with certain types of data structures (e.g., circular references).

Related benchmarks:

Lodash cloneDeep vs JSON Clone with huge array of objects (version: 0)

Comparing performance of: Lodash cloneDeep vs Json clone

Created: 3 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

Json clone

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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