Benchmark: Test performance of deep coping frok frok

HTML Preparation code:

<script src='https://unpkg.com/immutable@4.0.0-rc.12/dist/immutable.js'></script>
<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var initialScoreState = {
	1: {
		dataPoint: 'first_half_score',
		result: [-1, -1]
	},
	2: {
		dataPoint: 'second_half_score',
		result: [-1, -1]
	},
	111: {
		dataPoint: 'full_time_score',
		result: [-1, -1]
	}
};

function lodashClone() {
	_.cloneDeep(initialScoreState)
}

function jsonClone() {
	JSON.parse(JSON.stringify(initialScoreState));
}

function immutablejsClone() {
	Immutable.mergeDeep({}, initialScoreState);
}

Tests:

immutable js
immutablejsClone()
lodash
lodashClone()
JSON.parse(JSON.stringify
jsonClone()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
immutable js
lodash
JSON.parse(JSON.stringify

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 112 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
immutable js	1576323.9 Ops/sec
lodash	488325.8 Ops/sec
JSON.parse(JSON.stringify	567177.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Overview**

The provided JSON represents a benchmark test created using MeasureThat.net, a website that allows users to create and run JavaScript microbenchmarks. The test is designed to measure the performance of three different cloning libraries: Immutable.js, Lodash, and native JavaScript's `JSON.parse(JSON.stringify)` method.

**Options Compared**

The three options being compared are:

1. **Immutable.js**: A library for working with immutable data structures.
2. **Lodash**: A utility library that provides a lot of functional programming helpers, including cloning functions.
3. **Native JavaScript (`JSON.parse(JSON.stringify)`)**: The built-in method in JavaScript to create a deep copy of an object.

**Pros and Cons of Each Approach**

1. **Immutable.js**:
	* Pros: Immutable.js is designed for working with immutable data structures, which can lead to more predictable code and easier debugging.
	* Cons: It may introduce additional overhead due to the creation of new objects, which can impact performance in certain scenarios.
2. **Lodash**:
	* Pros: Lodash's `cloneDeep` function is a well-tested and widely used method for cloning JavaScript objects.
	* Cons: Lodash is a larger library, and its inclusion may add unnecessary overhead to the benchmark.
3. **Native JavaScript (`JSON.parse(JSON.stringify)`)**:
	* Pros: This approach is simple and efficient, as it leverages the built-in functionality of JavaScript.
	* Cons: However, this method has some limitations, such as not supporting all data types (e.g., objects with circular references).

**Library Descriptions**

1. **Immutable.js**: Immutable.js is a library that provides a way to work with immutable data structures. It does this by creating new objects and values instead of modifying existing ones. This approach can lead to more predictable code and easier debugging, but it may also introduce additional overhead.
2. **Lodash**: Lodash is a utility library that provides a wide range of functional programming helpers, including cloning functions. The `cloneDeep` function in particular is designed for creating deep copies of JavaScript objects.

**Special JS Features or Syntax**

In this benchmark, there are no specific special JS features or syntax being tested. However, it's worth noting that the use of libraries like Immutable.js and Lodash may require a good understanding of functional programming concepts and the underlying data structures being used.

**Other Alternatives**

If you're interested in exploring alternative cloning methods, here are a few options:

1. **JSON.parse(JSON.stringify(obj))**: This approach is simple and efficient but has limitations, such as not supporting all data types (e.g., objects with circular references).
2. **Array.prototype.slice() or Array.prototype.concat()**: These methods can be used to create shallow copies of arrays.
3. **Object.assign()**: This method can be used to create a shallow copy of an object.

Keep in mind that these alternatives may not provide the same level of immutability as Immutable.js, Lodash's `cloneDeep`, or native JavaScript's `JSON.parse(JSON.stringify)`.

Related benchmarks:

Test performance of deep coping frok frok (version: 0)

Comparing performance of: immutable js vs lodash vs JSON.parse(JSON.stringify

Created: 3 years ago by: Guest

Jump to the latest result

immutable js

lodash

JSON.parse(JSON.stringify

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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