Benchmark: extend vs cloneDeep vs JSON.*

HTML Preparation code:

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

Script Preparation code:

var myObj = {
    "name":"John",
    "age":30,
    "cars": {
        "car1":"Ford",
        "car2":"BMW",
        "car3":"Fiat"
    }
 }

Tests:

extend
let a = _.extend({}, myObj)
cloneDeep
let a = _.cloneDeep(myObj)
JSON.*
let a = JSON.parse(JSON.stringify(myObj))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
extend
cloneDeep
JSON.*

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation.

**Overview**

The provided JSON represents a JavaScript microbenchmarking test case on MeasureThat.net. The test measures the performance of three different approaches: extending an object, cloning it using `cloneDeep` from Lodash, and parsing a JSON string to create a new object.

**Options compared**

1. **Extend**: This approach uses the `_` object (from Lodash) to extend the original object (`myObj`) with new properties.
2. **CloneDeep**: This approach uses the `cloneDeep` function from Lodash to create a deep copy of the original object.
3. **JSON.***: This approach uses the `JSON.parse()` and `JSON.stringify()` methods to parse and recreate the original object.

**Pros and Cons**

1. **Extend**:
	* Pros: Simple, efficient, and suitable for most use cases.
	* Cons: May not work as expected if the target object is a primitive type (e.g., number or boolean).
2. **CloneDeep**:
	* Pros: Provides a deep copy of the original object, which can be useful in certain scenarios (e.g., when working with nested objects).
	* Cons: Requires Lodash, which adds an extra dependency.
3. **JSON.***:
	* Pros: Portable across environments and versions.
	* Cons: May not work correctly if the JSON string contains cyclic references or other complex data structures.

**Library usage**

The test case uses Lodash's `cloneDeep` function to clone the original object (`myObj`). This library provides a convenient way to perform deep copying of objects, but it requires an additional dependency.

**Special JS feature/syntax**

None mentioned in this specific benchmark. However, note that some older JavaScript engines (e.g., V8 prior to version 10) may not support all modern ES6+ features or methods used in the test cases (e.g., `const`, arrow functions, and object destructuring).

**Other alternatives**

If you need alternative approaches for cloning objects, consider using:

1. **`Object.assign()`**: A simpler approach that creates a shallow copy of an object.
2. **`JSON.parse(JSON.stringify(obj))` without Lodash**: A simple way to create a JSON string from an object and then parse it back into a new object. This method is more straightforward but may not work correctly with complex data structures or cyclic references.
3. **`Array.prototype.slice()` + `Object.assign()`**: For creating shallow copies of arrays.

These alternatives can be used in certain scenarios, but they might have different performance characteristics and requirements for compatibility.

Latest run results:

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

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

Browser/OS: Chrome 60 on Mac OS X 10.12.5

View result in a separate tab

Test name	Executions per second
extend	1358685.9 Ops/sec
cloneDeep	494668.8 Ops/sec
JSON.*	351109.5 Ops/sec

Related benchmarks:

extend vs cloneDeep vs JSON.* (version: 0)

Comparing performance of: extend vs cloneDeep vs JSON.*

Created: 7 years ago by: Guest

Jump to the latest result

extend

cloneDeep

JSON.*

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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