Benchmark: spread vs concat vs apply on large data set - 2

Tests:

array spread
const arr = [] for(i=0;i<10000;i++){ arr.push(i); } const arr2 = [1,2]; const newArray = [1,2,...arr]
array concat
const arr = [] for(i=0;i<10000;i++){ arr.push(i); } const arr2 = [1,2]; const newArray = arr2.concat(arr)
array push apply
const arr = [] for(i=0;i<10000;i++){ arr.push(i); } const arr2 = [1,2]; const newArray = arr2.push.apply(arr2, arr)
array spread in a push
const arr = [] for(i=0;i<10000;i++){ arr.push(i); } const arr2 = [1,2]; const newArray = arr2.push(...arr)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array spread
array concat
array push apply
array spread in a push

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated 27 days ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark test cases.

**Benchmark Purpose**

The goal of these tests is to compare the performance of three different ways to concatenate (combine) two large arrays in JavaScript: using the `spread` operator (`...`), the `concat()` method, and the `apply()` method with `push()`. The test case also includes an additional variation that uses the spread operator within a `push()` call.

**Test Case Descriptions**

Here's a brief overview of each test case:

1. **Array Spread**: Creates two large arrays (one with 10000 elements) and combines them using the spread operator (`...`) to create a new array.
2. **Array Concat**: Similar to the first test, but uses the `concat()` method to combine the two arrays.
3. **Array Push Apply**: This test creates a large array and uses the `apply()` method with `push()` to add elements from another array. However, it's worth noting that `apply()` is not typically used in this way, and its use here might be considered an edge case or a testing contrivance.
4. **Array Spread in a Push**: This test combines the spread operator with a push operation to add elements from one array to another.

**Results Analysis**

The latest benchmark results show the execution speed (measured as Executions Per Second) for each test case on Chrome 110 browser:

1. Array Concat: ~23571 executions per second
2. Array Spread in a Push: ~15329 executions per second
3. Array Push Apply: ~15224 executions per second
4. Array Spread: ~12844 executions per second

**Interpretation**

The results indicate that the `concat()` method is significantly faster than using the spread operator or applying/pushing elements individually.

**Pros and Cons of each approach**

1. **Array Concat**: Pros: Fastest performance in this benchmark; Cons: May be slower if you're pushing elements one by one.
2. **Array Spread**: Pros: Easy to read and write, especially when spreading multiple arrays or objects; Cons: Slower than concat(), may use more memory.
3. **Array Push Apply**: Not a typical use case for `apply()`; might be considered an edge case.

**Alternatives**

Other alternatives to concatenate arrays include:

* Using the `push()` method with individual elements, but this would be slower than using `concat()` or spread operators.
* Using ES6's `Set` and spreading it into an array (not shown in these tests), which might offer better performance for large datasets.

**Library Usage**

No external libraries are used in these test cases.

**Special JS Feature or Syntax**

The test case uses the spread operator (`...`) to combine arrays, as well as ES5's `apply()` method with `push()`. The latest test also utilizes the spread operator within a `push()` call.

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/110.0.0.0 Safari/537.36

Browser/OS: Chrome 110 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
array spread	12845.0 Ops/sec
array concat	23571.7 Ops/sec
array push apply	15224.2 Ops/sec
array spread in a push	15329.8 Ops/sec

Related benchmarks:

spread vs concat vs apply on large data set - 2 (version: 1)

Large data set is the difference

Comparing performance of: array spread vs array concat vs array push apply vs array spread in a push

Created: 6 years ago by: Registered User

Jump to the latest result

array spread

array concat

array push apply

array spread in a push

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.1:latest, generated 27 days ago):