Benchmark: concat vs spread vs push vs push spread vs push loop

Tests:

concat
var params = [ "hello", true, 7 ]; var other = [ 1, 2 ].concat(params);
spread
var params = [ "hello", true, 7 ] var other = [ 1, 2, ...params ]
push
var params = [ "hello", true, 7 ]; params.push(1); params.push(2);
push spread
var params = [ "hello", true, 7 ]; params.push(...[1, 2]);
push loop
var params = [ "hello", true, 7 ]; for (let i = 1; i <= 2; i++) { params.push(i); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
concat
spread
push
push spread
push loop

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):

LLMs can make mistakes. Check important info.

Measuring the performance of different JavaScript array operations is crucial for optimizing code and improving overall application performance.

The provided benchmark definition measures the execution time of four different approaches to add elements to an array:

1. **Concatenation (`concat`)**: This involves using the `+` operator or the `concat()` method to merge two arrays.
2. **Spread syntax (`spread`)**: This uses the `...` operator to spread the elements of one array into another.
3. **Push with no spread (`push`)**: This adds elements to an array using the `push()` method without spreading any other array.
4. **Push with spread (`push spread`)**: Similar to the previous option, but spreads another array before adding elements.

**Pros and Cons of each approach:**

* **Concatenation (`concat`)**:
	+ Pros: Simple and widely supported, can be efficient for small arrays.
	+ Cons: Creates a new array, which can lead to increased memory usage; slow for large arrays due to the overhead of creating a new object.
* **Spread syntax (`spread`)**:
	+ Pros: Faster and more efficient than concatenation for large arrays, as it avoids creating a new array; modern and widely supported.
	+ Cons: Requires support for ES6+ syntax, which may not be compatible with older browsers or versions of JavaScript.
* **Push with no spread (`push`)**:
	+ Pros: Simple and fast, as it directly modifies the original array without creating a new one.
	+ Cons: May lead to unexpected behavior if not used carefully (e.g., modifying the array while iterating over it).
* **Push with spread (`push spread`)**:
	+ Pros: Combines the benefits of concatenation and push methods; avoids the overhead of creating a new array.
	+ Cons: Less intuitive than other approaches, as it involves spreading another array before adding elements.

**Other considerations:**

* For small arrays, all four approaches may be acceptable, but for larger arrays, spread syntax (`spread`) is generally recommended due to its efficiency and modernity.
* Push with no spread (`push`), while simple and fast, can lead to unexpected behavior if not used carefully. It's essential to understand the implications of modifying an array while iterating over it.

**Library usage:**

There are no libraries mentioned in the provided benchmark definition. All operations rely on built-in JavaScript methods or syntax features.

**Special JS feature/syntax:**

The spread syntax (`spread`) relies on ES6+ syntax support, which is widely adopted but not compatible with older browsers or versions of JavaScript. Other approaches use standard JavaScript methods (e.g., `concat()`, `push()`).

Alternatives to these benchmarks:

* Other array operations, such as `setLength()`, `splice()`, or `slice()`.
* Benchmarks for different data structures, like arrays vs. objects or linked lists.
* Workload-specific benchmarks, such as parsing JSON or executing complex algorithms.

Keep in mind that the performance characteristics of these approaches can vary depending on specific use cases and environments.

Latest run results:

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

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

Browser/OS: Chrome 74 on Mac OS X 10.14.4

View result in a separate tab

Test name	Executions per second
concat	5088675.5 Ops/sec
spread	25623206.0 Ops/sec
push	31491736.0 Ops/sec
push spread	20276386.0 Ops/sec
push loop	32971132.0 Ops/sec

Related benchmarks:

concat vs spread vs push vs push spread vs push loop (version: 0)

Comparing performance of: concat vs spread vs push vs push spread vs push loop

Created: 5 years ago by: Guest

Jump to the latest result

concat

spread

push

push spread

push loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 29 days ago):