Benchmark: Deep Object Cloning

HTML Preparation code:

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

Script Preparation code:

var o = {
 a: {
   b: 1,
   c: 2,
   d: 3,
   j: {
     k: [1,2,3],
     l: [4,5,6]
   },
 },
 e: [1,2,3,4,5,6],
 f: 1,
 g: {
   h: 1,
 }
}

Tests:

Lodash cloneDeep
const a = _.cloneDeep(o)
jQuery Extend
const a = $.extend({}, o);
lodash assign
const a = _.assign({}, o)
JSON Parsing
const a = JSON.parse(JSON.stringify(o));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash cloneDeep
jQuery Extend
lodash assign
JSON Parsing

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 benchmark definition and individual test cases to explain what is tested, the options compared, their pros and cons, and other considerations.

**Benchmark Definition**

The benchmark definition represents a JavaScript microbenchmark that tests various ways to perform deep object cloning. The original object `o` has several nested properties, including arrays `[k]` and `[l]`, which contain lists of numbers.

**Individual Test Cases**

There are four test cases:

1. **Lodash cloneDeep**: This test case uses the `_cloneDeep` function from the Lodash library to create a deep copy of the original object `o`.
2. **jQuery Extend**: This test case uses the `$extend` function from the jQuery library to merge the original object `o` with an empty object, effectively creating a shallow copy.
3. **Lodash assign**: This test case uses the `_assign` function from the Lodash library to create a new object that is a shallow copy of the original object `o`.
4. **JSON Parsing**: This test case uses the `JSON.parse(JSON.stringify(o))` syntax to create a deep copy of the original object `o`.

**Options Compared**

Each test case compares two different approaches for performing deep object cloning:

* Lodash cloneDeep vs. jQuery Extend and Lodash assign
* JSON Parsing

**Pros and Cons of Each Approach**

Here's a brief overview of each approach:

1. **Lodash cloneDeep**: This is the most efficient method for deep object cloning, as it uses a recursive algorithm to create a precise copy of the original object.
	* Pros: Fast, accurate, and reliable
	* Cons: Requires Lodash library, which may not be included in all environments
2. **jQuery Extend**: This approach creates a shallow copy by merging the original object with an empty object, which is sufficient for most cases but may not preserve all nested properties.
	* Pros: Fast, lightweight, and easy to implement
	* Cons: May not work correctly with deeply nested objects or complex data structures
3. **Lodash assign**: Similar to jQuery Extend, this approach creates a shallow copy by merging the original object with an empty object.
	* Pros: Fast, lightweight, and easy to implement
	* Cons: May not work correctly with deeply nested objects or complex data structures
4. **JSON Parsing**: This approach uses the `JSON.parse(JSON.stringify(o))` syntax to create a deep copy of the original object. While it's a simple and elegant solution, it may not be as efficient as other methods, especially for very large objects.
	* Pros: Easy to implement, lightweight
	* Cons: May not work correctly with certain data types (e.g., functions) or deeply nested objects

**Other Considerations**

When choosing an approach for deep object cloning, consider the following factors:

* Performance: If you need high-performance cloning, Lodash cloneDeep may be the best choice.
* Compatibility: If you need to support older browsers or environments without Lodash, jQuery Extend or Lodash assign might be a better option.
* Data complexity: For very large or complex objects, Lodash cloneDeep or JSON Parsing might be more suitable.

**Alternatives**

If you're looking for alternative approaches for deep object cloning, consider the following:

1. **Pure**: A lightweight and efficient library that provides a deep copy function.
2. **Immer**: A library that provides a safe and efficient way to update objects without creating copies.
3. **Object.assign() with Object.create()**: This approach creates a new object using `Object.create()` and then uses `Object.assign()` to clone the original object.

These alternatives may offer different trade-offs in terms of performance, compatibility, and complexity, so be sure to evaluate them carefully based on your specific needs.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.3 Safari/605.1.15

Browser/OS: Safari 14 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash cloneDeep	171808.9 Ops/sec
jQuery Extend	1804957.8 Ops/sec
lodash assign	1303922.9 Ops/sec
JSON Parsing	246900.2 Ops/sec

Related benchmarks:

Deep Object Cloning (version: 0)

Comparing performance of: Lodash cloneDeep vs jQuery Extend vs lodash assign vs JSON Parsing

Created: 3 years ago by: Guest

Jump to the latest result

Lodash cloneDeep

jQuery Extend

lodash assign

JSON Parsing

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