Benchmark: jsonparse vs structuredClone

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 = {
  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 = JSON.parse(JSON.stringify(MyObject));
Native structuredClone
myCopy = structuredClone(MyObject);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
Native structuredClone

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 break down what's being tested in the provided JSON benchmark.

**Benchmark Definition**

The benchmark tests two approaches to create a deep copy of an object: `JSON.parse(JSON.stringify(MyObject))` (using Lodash) and `structuredClone(MyObject)` (using the native JavaScript method).

**Options Compared**

The options being compared are:

1. **Lodash's `cloneDeep()` function**: This is a utility function from the Lodash library that creates a deep copy of an object.
2. **Native `structuredClone()` function**: This is a new method introduced in ECMAScript 2020, which allows you to create a deep copy of an object.

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Lodash's `cloneDeep()` function**
	* Pros:
		+ Well-tested and widely used library
		+ Provides additional features beyond simple copying (e.g., handling circular references)
	* Cons:
		+ Adds an external dependency to the benchmark (Lodash)
		+ May introduce overhead due to the complexity of the cloning algorithm
2. **Native `structuredClone()` function**
	* Pros:
		+ Built-in, so no external dependencies are introduced
		+ Optimized for performance by the browser engine
	* Cons:
		+ Only available in recent browsers that support ECMAScript 2020
		+ May not be as widely tested or well-understood as Lodash's `cloneDeep()`

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks such as array manipulation, string manipulation, and object manipulation. The `cloneDeep()` function in particular is designed to create deep copies of objects, handling circular references and other edge cases.

**Other Considerations**

When choosing between these two approaches, consider the following factors:

* Performance: The native `structuredClone()` function may be faster due to its built-in nature and optimization by the browser engine.
* Maintenance: If you're using a library like Lodash, you'll need to manage its dependencies and potential updates.
* Compatibility: If you want to ensure compatibility with older browsers that don't support ECMAScript 2020, you may need to stick with Lodash's `cloneDeep()` function.

**Alternatives**

If you need alternative ways to create deep copies of objects, consider the following:

1. **JSON.parse(JSON.stringify(object))**: This is a simple but limited approach that only creates a shallow copy of the object.
2. **Array.prototype.slice() and Array.prototype.concat()**: These methods can be used to create a shallow copy of an array by concatenating it with itself.
3. **for...in loops and Object.assign()**: You can use these methods to manually iterate over the properties of an object and create a new object with the same properties.

Keep in mind that these alternatives may not handle circular references or other edge cases as well as Lodash's `cloneDeep()` function or the native `structuredClone()` method.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36

Browser/OS: Chrome 109 on Linux

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	491056.3 Ops/sec
Native structuredClone	319242.7 Ops/sec

Related benchmarks:

jsonparse vs structuredClone (version: 0)

https://developer.mozilla.org/en-US/docs/Web/API/structuredClone

Comparing performance of: Lodash cloneDeep vs Native structuredClone

Created: one year ago by: Guest

Jump to the latest result

Lodash cloneDeep

Native structuredClone

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):