Benchmark: deep-copy-compare

HTML Preparation code:

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

Script Preparation code:

var address = {
  "prefix": "",
  "suffix": "",
  "firstName": "Bryan",
  "middleName": null,
  "lastName": "Nichols",
  "line1": "13256 NE 20TH ST",
  "line2": "",
  "city": "BELLEVUE",
  "stateCode": "WA",
  "postalCode": "98005-2021",
  "countryCode": "US",
  "phoneNumber": "4254445555",
  "scrubStatus": "SCRUBBED_ADDRESS",
  "isPayPalAddress": false,
  "storeId": null,
  "storeDisplayName": null,
  "storeTimeZoneId": null,
  "storeShipToNumber": null,
  "isDefault": false
}

Tests:

JSON.parse
var foo = JSON.stringify(JSON.parse(address));
cloneDeep
var foo = _.cloneDeep(address);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
JSON.parse
cloneDeep

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 world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition and Script Preparation Code**

The benchmark definition is a JSON object that describes two individual test cases:

1. `JSON.parse`
2. `cloneDeep`

The script preparation code provides an initial JavaScript context, which includes a single object `address`. This object contains various properties with different data types (e.g., strings, numbers, null).

**Options being compared**

In this benchmark, we're comparing two approaches to deep copying:

1. **JSON.parse**: This method parses the JSON string representation of the input object and returns it as a JavaScript object.
2. **cloneDeep**: This function is part of the Lodash library (imported via `lodash.min.js` script) and creates a deep copy of the input object.

**Pros and Cons**

* **JSON.parse**:
	+ Pros: Simple, widely supported, and efficient for simple cases.
	+ Cons: Can be slower than dedicated copying libraries like Lodash, as it involves parsing the JSON string. Additionally, it may not work correctly with complex data structures or circular references.
* **cloneDeep**:
	+ Pros: Designed specifically for deep copying, handles complex data structures, and supports circular references. It's often faster than manual implementation or `JSON.parse` alone.
	+ Cons: Requires Lodash library, which might add unnecessary overhead for some use cases.

**Lodash library**

The provided HTML preparation code includes the Lodash library via a CDN link. The `cloneDeep` function is a part of this library, which is commonly used in JavaScript development for its ability to handle complex data structures and deep copying.

**Other considerations**

* **Browser-specific optimizations**: The benchmark might be affected by browser-specific optimizations or caching, which could impact the actual performance results.
* **Environment variables and context**: The benchmark execution environment might vary depending on factors like platform, CPU architecture, memory constraints, or other system-level settings.

**Alternatives to cloneDeep**

If you need a similar deep copying functionality without using Lodash, you can consider implementing your own custom implementation. Some popular alternatives include:

* `JSON.parse(JSON.stringify(obj))` (similar to `cloneDeep`, but with some limitations)
* `Array.prototype.slice.call(obj)` or `Object.assign({}, obj)` for shallow copying
* Manual recursive implementation (more efficient than using Lodash)

Keep in mind that implementing a robust deep copying solution can be complex and error-prone, so it's recommended to use established libraries like Lodash unless you have specific performance or customization requirements.

Latest run results:

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

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

Browser/OS: Chrome 63 on Mac OS X 10.12.6

View result in a separate tab

Test name	Executions per second
JSON.parse	0.0 Ops/sec
cloneDeep	341570.5 Ops/sec

Related benchmarks:

deep-copy-compare (version: 0)

Comparing performance of: JSON.parse vs cloneDeep

Created: 6 years ago by: Guest

Jump to the latest result

JSON.parse

cloneDeep

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