Benchmark: Array push vs Array spread vs Array concat experiment

Tests:

Add with push
const element = (index) => ({ id: new Date().getTime() + index, name: `Element_${index}` }) const list1 = Array(100).fill({}).map((_, index) => element(index)) const list2 = Array(100).fill({}).map((_, index) => element(index)) const list3 = list1.push(...list2)
Add with spread operator
const element = (index) => ({ id: new Date().getTime() + index, name: `Element_${index}` }) const list1 = Array(100).fill({}).map((_, index) => element(index)) const list2 = Array(100).fill({}).map((_, index) => element(index)) const list3 = [...list1, ...list2]
Add with array concat
const element = (index) => ({ id: new Date().getTime() + index, name: `Element_${index}` }) const list1 = Array(100).fill({}).map((_, index) => element(index)) const list2 = Array(100).fill({}).map((_, index) => element(index)) const list3 = list1.concat(list2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Add with push
Add with spread operator
Add with array concat

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.

The provided JSON represents a JavaScript benchmarking test case, specifically an experiment to compare the performance of three different methods for adding elements to an array: `push`, `spread operator`, and `concat`.

**What is tested?**

In this test case, we have three individual test cases:

1. **Add with push**: This test case checks the performance of using the `push()` method to add elements to an array.
2. **Add with spread operator**: This test case checks the performance of using the spread operator (`...`) to add elements to an array.
3. **Add with array concat**: This test case checks the performance of using the `concat()` method to add elements to an array.

**Options compared**

The three options are compared in terms of their execution speed, measured in executions per second (EPS). The results show that:

* `push` is the fastest option, with an EPS of 11078.107421875.
* `spread operator` is slightly slower than `push`, with an EPS of 10947.2060546875.
* `concat` is the slowest option, with an EPS of 10921.8603515625.

**Pros and cons**

Here are some pros and cons of each approach:

* **Push**: Fastest, but may not be as memory-efficient since it creates a new array element on each push operation. Pros: simple to use, fast execution speed. Cons: potential memory issues.
* **Spread operator**: Slightly slower than `push`, but more memory-efficient since it uses the existing array elements and doesn't create new ones. Pros: good balance between performance and memory usage. Cons: may be slightly slower than `push`.
* **Concat**: Slowest, but can be useful when working with large datasets or when you need to preserve the original array's structure. Pros: preserves original array's structure, can be used with large datasets. Cons: slow execution speed.

**Library and purpose**

In this test case, there is no specific library being used beyond the built-in JavaScript `Array` methods. The libraries are just native JavaScript features that are part of the language itself.

**Special JS feature or syntax**

There are no special JS features or syntax used in this test case. The tests only use standard JavaScript methods and operators.

**Other alternatives**

If you want to explore other alternatives for adding elements to an array, some other options include:

* Using `Array.prototype.push.apply()` method, which is similar to using the spread operator but more explicit.
* Using a loop with a for...of loop or a traditional for loop to add elements to the array.
* Using a library like Lodash, which provides a `concat` function that can be used instead of the built-in `Array.concat()` method.

Keep in mind that these alternatives may have different performance characteristics and use cases compared to the standard `push`, spread operator, or concat methods.

Related benchmarks:

Array push vs Array spread vs Array concat experiment (version: 0)

Comparing performance of: Add with push vs Add with spread operator vs Add with array concat

Created: 5 years ago by: Registered User

Jump to the latest result

Add with push

Add with spread operator

Add with array concat

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