Benchmark: JSON VS CLONEDEEP

HTML Preparation code:

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

Script Preparation code:

var data = { stocks:
   [ { blockName: 'GA0001',
       categoryName: 'R18 Early Entry Package',
       seatsAvailable: 40,
       price: 81.74,
       currency: 'NZD',
       code: 'EARLY',
       message: 'VIP',
       isAccessibility: false,
       isSpecial: true,
       isResale: false,
       stockByRow: {} },
     { blockName: 'GA0002',
       categoryName: 'R18 General Admission Standing',
       seatsAvailable: 301,
       price: 61.28,
       currency: 'NZD',
       code: 'R18 General Admission Standing',
       message: 'AGE_RESTRICTED',
       isAccessibility: false,
       isSpecial: true,
       isResale: false,
       stockByRow: {} },
     { blockName: 'GA0003',
       categoryName: 'R18 General Admission Standing',
       seatsAvailable: 50,
       price: 61.28,
       currency: 'NZD',
       code: 'R18 General Admission Standing',
       message: 'AGE_RESTRICTED',
       isAccessibility: false,
       isSpecial: true,
       isResale: false,
       stockByRow: {} } ],
  type: 'category' };

var copyData = null;

Tests:

json
copyData = JSON.parse(JSON.stringify(data));
clonedeep
copyData = _.cloneDeep(data);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
json
clonedeep

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the provided benchmarking code and explain what's being tested.

**Benchmark Definition**

The benchmark is comparing two ways to create a deep copy of an object: using `JSON.parse(JSON.stringify(data))` (denoted as "json") and using Lodash's `_cloneDeep()` function (denoted as "clonedeep").

**What are we testing?**

We're testing the performance difference between these two approaches in creating a deep copy of an object. Specifically, we're measuring how many executions per second each method can handle.

**Options compared**

There are two options being compared:

1. **JSON.parse(JSON.stringify(data))**: This is a built-in JavaScript method that uses serialization and deserialization to create a deep copy of an object. However, this method has some limitations, such as not working correctly with circular references or objects containing functions.
2. **Lodash's `_cloneDeep()` function**: This is a third-party library that provides a robust way to create deep copies of objects.

**Pros and cons**

Here are the pros and cons of each approach:

* **JSON.parse(JSON.stringify(data))**:
	+ Pros: Simple, lightweight, and widely supported.
	+ Cons: May not work correctly with circular references or objects containing functions.
* **Lodash's `_cloneDeep()` function**:
	+ Pros: Robust, handles complex scenarios, and supports many data structures (e.g., arrays, objects).
	+ Cons: Requires including the Lodash library, which adds overhead.

**Library used**

In this benchmark, the Lodash library is being used for its `_cloneDeep()` function. The library provides a more robust way to create deep copies of objects, but it also introduces additional overhead due to the need to include the library in the test environment.

**Special JS feature or syntax**

There are no special JavaScript features or syntaxes being tested in this benchmark. Both approaches use standard JavaScript methods and libraries (Lodash).

**Other alternatives**

If you were to implement a deep copy algorithm from scratch, without using Lodash, you could explore other options like:

* Iterative approach: Use loops to recursively create new objects and assign properties.
* Recursive approach with memoization: Use recursive functions to create new objects and store intermediate results in a cache (memo) to avoid redundant work.

Keep in mind that implementing such an algorithm from scratch can be more complex and slower than using existing libraries like Lodash.

I hope this explanation helps!

Latest run results:

Run details: (Test run date: 6 years ago)

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

Browser/OS: Chrome 68 on Mac OS X 10.12.6

View result in a separate tab

Test name	Executions per second
json	64342.1 Ops/sec
clonedeep	146162.9 Ops/sec

Related benchmarks:

JSON VS CLONEDEEP (version: 0)

Comparing performance of: json vs clonedeep

Created: 6 years ago by: Guest

Jump to the latest result

json

clonedeep

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):