Benchmark: Concat() vs. Unshift()

Script Preparation code:

var arr = ['', '', ''];

Tests:

Concat()
arr = [27].concat(arr);
Unshift()
arr.unshift(27);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Concat()
Unshift()

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36 OPR/126.0.0.0

Browser/OS: Opera 126 on Linux

View result in a separate tab

Test name	Executions per second
Concat()	8939.5 Ops/sec
Unshift()	47434.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down what's being tested in the provided JSON.

**Benchmark Definition**
The benchmark is comparing two JavaScript methods: `concat()` and `unshift()`. The goal is to measure which method is faster for appending elements to an array.

**Options Compared**

* `concat()`: This method creates a new array by concatenating the original array with the specified elements. It returns a new array, leaving the original unchanged.
	+ Pros: Easy to use, straightforward syntax, and doesn't modify the original array.
	+ Cons: Creates a new array object, which can be memory-intensive for large datasets.
* `unshift()`: This method adds one or more elements to the beginning of an array. It modifies the original array and returns the updated array.
	+ Pros: More efficient than `concat()` for adding multiple elements at once, as it only needs to update the reference count of the array.
	+ Cons: Modifies the original array, which can be undesirable in some cases.

**Other Considerations**

* The benchmark doesn't account for other factors that might affect performance, such as array size, type (e.g., integers vs. strings), or the presence of other JavaScript features like closures or async operations.
* The test uses a simple array with three elements to keep things straightforward. More complex scenarios, like larger arrays or multiple concurrent updates, might reveal different performance characteristics.

**Library and Special JS Features**

There is no library mentioned in the provided JSON. However, it's worth noting that libraries like Lodash or Ramda provide alternative implementations of `concat()` and other array methods that might affect performance.

No special JavaScript features are used in this benchmark. If they were present (e.g., async/await, generators, or Web Workers), they would be applied to the script preparation code or test cases themselves.

**Benchmark Preparation Code**

The script preparation code creates an empty array `arr` with three elements: `''`, `'']`, and `'')`. This is used as the base for both benchmarking approaches.

**Individual Test Cases**

The two test cases define how each method is used:

1. `Concat()`: Creates a new array by concatenating `[27]` to the original `arr`.
2. `Unshift()`: Adds the single element `27` to the beginning of the original `arr`.

These test cases are simple and focus on demonstrating the performance difference between `concat()` and `unshift()`.

**Latest Benchmark Result**

The latest benchmark result shows that:

* `Unshift()` outperforms `Concat()` by a significant margin (399.84 executions per second vs. 1465.43 executions per second) for the test case with a single element (`[27]`).
* The execution counts are based on running the benchmarks in Firefox 108 on a desktop device.

This result highlights the efficiency of `unshift()` over `concat()` when adding a single element to an array, but may not reflect real-world scenarios where arrays have multiple elements or other factors influence performance.

Related benchmarks:

Concat() vs. Unshift() (version: 0)

Comparing performance of: Concat() vs Unshift()

Created: 4 years ago by: Guest

Jump to the latest result

Concat()

Unshift()

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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