Benchmark: deepcopy vs splice

Script Preparation code:

var list = [...Array(1000).keys()].map((index) => {return {id: index, name: `PRODUCT_${index}`}});
var deepCopy = function deepCopy(item) {
   return JSON.parse(JSON.stringify(item));
}

Tests:

deepCopy
const copy = deepCopy(list); list[50] = {id: 50, name: 'CUST_50'};
splice
list.splice(49, 1, {id: 50, name: 'CUST_50'});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
deepCopy
splice

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Definition JSON:**
The provided JSON represents a benchmark definition for measuring the performance difference between two approaches: `deepcopy` and `splice`. The script preparation code defines an array `list` with 1000 objects, each containing `id` and `name` properties.

**Script Preparation Code:**
```javascript
var list = [...Array(1000).keys()].map((index) => {return {id: index, name: `PRODUCT_${index}`}});

var deepCopy = function deepCopy(item) {
   return JSON.parse(JSON.stringify(item));
}
```
The script preparation code creates an array `list` with 1000 objects using the spread operator and a map function. It also defines a custom `deepCopy` function, which uses `JSON.parse()` and `JSON.stringify()` to create a deep copy of the input object.

**Html Preparation Code:**
There is no HTML preparation code provided in this benchmark definition.

**Individual Test Cases:**
The benchmark consists of two individual test cases:

1. **"deepCopy"`:
```javascript
const copy = deepCopy(list);
list[50] = {id: 50, name: 'CUST_50'};
```
This test case creates a deep copy of the `list` array using the custom `deepCopy` function and then modifies the original array by assigning a new object to the 50th index.

2. **"splice"`:
```javascript
list.splice(49, 1, {id: 50, name: 'CUST_50'});
```
This test case uses the `splice()` method to insert a new object into the 50th position of the original `list` array.

**Benchmark Results:**
The latest benchmark results show that:

* The "splice" approach outperforms the "deepCopy" approach, with approximately 2.4 times more executions per second (21053492 vs 8693.6923828125).

**Options Compared:**

1. **Deep Copy**: Using a custom function to create a deep copy of the array using `JSON.parse()` and `JSON.stringify()`.
	* Pros:
		+ Provides a controlled and predictable way to create a deep copy.
		+ Can be useful when working with complex data structures.
	* Cons:
		+ May incur additional memory overhead due to the use of `JSON` parsing.
		+ May not work correctly for all types of objects (e.g., non- JSON serializable objects).
2. **Splice**: Using the `splice()` method to modify the array in-place.
	* Pros:
		+ Highly optimized and efficient, as it modifies the original array directly.
		+ Does not incur additional memory overhead.

**Library Used:**
None of the provided code uses any external libraries. The `JSON` object is a built-in JavaScript library.

**Special JS Feature/Syntax:**
There are no special JavaScript features or syntax used in this benchmark definition (e.g., ES6 classes, async/await, or arrow functions).

**Other Alternatives:**
Alternative approaches to deep copying and array modification could include:

1. Using `Array.prototype.slice()` to create a shallow copy of the array.
2. Using `Array.prototype.forEach()` to iterate over the array and create a new copy.
3. Using a library like Lodash's `cloneDeep()` function to create a deep copy.

Keep in mind that these alternatives may have different performance characteristics and might not be as efficient as the custom `deepCopy` function or the optimized `splice()` method.

Related benchmarks:

deepcopy vs splice (version: 0)

Comparing performance of: deepCopy vs splice

Created: 8 years ago by: Registered User

Jump to the latest result

deepCopy

splice

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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