Benchmark: Cloning arrays - MeasureThat.net

Script Preparation code:

var original = new Array(100);
for (let r = 0; r < 100; r++) {
  original[r] = [];
  for (let c = 0; c < 100; c++) {
    original[r][c] = r * 100 + c;
  }
}

Tests:

splice
var copy = new Array(original.length); for (let r = 0; r < original.length; r++) { copy[r] = original[r].splice(0); }
map
var copy = original.map(row => row.splice(0));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
splice
map

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 break down the provided benchmark and its results.

**Benchmark Definition**

The benchmark definition represents a JavaScript code snippet that clones an array of arrays, where each inner array has 100 elements with values generated by multiplying the row index (r) by 100 and adding the column index (c). The goal is to measure how fast different approaches can create a copy of this large two-dimensional array.

**Script Preparation Code**

The script preparation code creates the original array `original` and populates it with data:
```javascript
var original = new Array(100);
for (let r = 0; r < 100; r++) {
  original[r] = [];
  for (let c = 0; c < 100; c++) {
    original[r][c] = r * 100 + c;
  }
}
```
This code is executed before running the test cases.

**Html Preparation Code**

The html preparation code is empty, which means it doesn't perform any additional setup or preparation for the benchmark.

**Individual Test Cases**

There are two test cases:

1. **splice**
```javascript
var copy = new Array(original.length);
for (let r = 0; r < original.length; r++) {
  copy[r] = original[r].splice(0);
}
```
This approach uses `Array.prototype.splice()` to remove the first element from each inner array and assign the result to a new array. The `copy` variable will contain the cloned data.

2. **map**
```javascript
var copy = original.map(row => row.splice(0));
```
This approach uses the `Array.prototype.map()` method with a callback function that removes the first element from each inner array and returns the result. The `copy` variable will contain the cloned data.

**Benchmark Results**

The latest benchmark results show the performance of both test cases:

1. **map**
```json
"ExecutionsPerSecond": 362622.0,
```
This approach executes approximately 362,622 times per second on a Mac with Yandex Browser 24 and Mac OS X 10.15.7.

2. **splice**
```json
"ExecutionsPerSecond": 64149.359375,
```
This approach executes approximately 64,149 executions per second on the same machine.

**Comparison of Approaches**

Here's a brief comparison of the two approaches:

1. **map()**: This approach is generally faster because it uses a more efficient algorithm that avoids iterating over the inner arrays multiple times.
2. **splice()**: This approach is slower due to the overhead of calling `Array.prototype.splice()` and modifying the original array.

**Pros and Cons**

Pros of `map()`:

* Faster execution
* Less memory allocation and deallocation

Cons of `map()`:

* May require additional memory for the callback function's scope
* May not be as readable or maintainable due to the use of a callback function

Pros of `splice()`:

* More control over the cloning process
* Can be more readable if using a custom implementation

Cons of `splice()`:

* Slower execution
* More memory allocation and deallocation

**Alternative Approaches**

Some alternative approaches for cloning arrays in JavaScript include:

1. **Array.prototype.slice()**: This method creates a shallow copy of an array, which may not work well for 2D arrays.
```javascript
var copy = original.map(row => row.slice());
```
2. **Array.prototype.reduce()**: This method can be used to create a deep copy of an array by reducing the inner arrays to their first elements.
```javascript
var copy = original.map(row => row.reduce((a, b) => [b], [])[0]);
```
3. **libya.array.clone()**: This is a utility function that creates a deep clone of an array.
```javascript
const { cloneArray } = require('libya.array');
var copy = cloneArray(original);
```

Note: These alternative approaches may have different trade-offs in terms of performance, memory usage, and readability.

Latest run results:

Run details: (Test run date: 5 months ago)

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

Browser/OS: Yandex Browser 24 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
splice	64149.4 Ops/sec
map	362622.0 Ops/sec

Related benchmarks:

Cloning arrays (version: 0)

Comparing performance of: splice vs map

Created: 7 years ago by: Guest

Jump to the latest result

splice

map

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