Benchmark: array concatination

Script Preparation code:

var array = [];
for (let i = 0; i < 100; i++ ) {
    array.push(i)
}

var test = null;

Tests:

unshift
test = array.unshift(0);
concat
test = [0].concat(array)
spread
test = [0, ...array]

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
unshift
concat
spread

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 93 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
unshift	10315.7 Ops/sec
concat	3435.4 Ops/sec
spread	682.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The benchmark is designed to measure the performance of three different approaches for concatenating an array:

1. Using `array.unshift(0)`: This approach modifies the original array by adding a new element at the beginning.
2. Using `[0].concat(array)`: This approach creates a new array by copying the elements from the original array using the spread operator (`...`).
3. Using `[0, ...array]`: This approach uses the spread operator to create a new array that includes all elements of the original array.

**Options Compared**

The benchmark compares the performance of these three approaches:

* **Pros and Cons:**
	+ `array.unshift(0)`: This approach is simple and efficient but modifies the original array, which might not be desirable for some use cases. It's also vulnerable to edge cases where the resulting array has a different length than the original.
	+ `[0].concat(array)`: This approach creates a new array without modifying the original, making it safer and more predictable. However, it uses more memory and is potentially slower due to the creation of a new array.
	+ `[0, ...array]`: This approach is concise and efficient, creating a new array that includes all elements of the original. It's also safe and predictable, but might not be as well-known or widely supported as the other two approaches.
* **Other Considerations:**
	+ The benchmark does not account for the length of the original array, which could impact performance. A larger array would result in more modifications, concatenations, or copies, potentially affecting performance.
	+ The benchmark uses a relatively small array size (100 elements). For larger arrays, these approaches might exhibit different performance characteristics.

**Library and Special JS Features**

In this benchmark, none of the libraries are explicitly mentioned. However, it's essential to note that modern JavaScript engines have built-in support for various features like `Array.prototype.unshift()`, spread syntax (`...`), and array concatenation.

The use of `[0].concat(array)` is a common pattern in JavaScript, but using `[0, ...array]` is a more concise alternative that has gained popularity in recent years. MeasureThat.net's benchmark helps compare the performance of these different approaches.

**Other Alternatives**

While not explicitly mentioned in this benchmark, other alternatives for concatenating arrays include:

* `Array.prototype.concat()`: This method is also used in `[0].concat(array)`.
* Using a library like Lodash (`_.concat()` or `_.union()`).
* Implementing a custom array concatenation function using `Array.prototype.slice()` and `Array.prototype.push()`.

Keep in mind that these alternatives might have different performance characteristics, especially for large arrays or specific use cases. MeasureThat.net's benchmark provides a general insight into the relative performance of these approaches.

Related benchmarks:

array concatination (version: 1)

Comparing performance of: unshift vs concat vs spread

Created: 3 years ago by: Registered User

Jump to the latest result

unshift

concat

spread

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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