Benchmark: Push performances

Script Preparation code:

class X { uuid = "0123456789ABCDEF" }
x = new X()

var array1 = Array(1).fill(x)
var array10 = Array(10).fill(x)
var array100 = Array(100).fill(x)
var array500 = Array(500).fill(x)
var array1000 = Array(1000).fill(x)

Tests:

Array + 1
var array = array100.push(...array1)
Array + 10
var array = array100.push(...array10)
Array + 100
var array = array100.push(...array100)
Array + 500
var array = array100.push(...array500)
Array + 1000
var array = array100.push(...array1000)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array + 1
Array + 10
Array + 100
Array + 500
Array + 1000

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:75.0) Gecko/20100101 Firefox/75.0

Browser/OS: Firefox 75 on Ubuntu

View result in a separate tab

Test name	Executions per second
Array + 1	3883380.8 Ops/sec
Array + 10	827246.2 Ops/sec
Array + 100	0.0 Ops/sec
Array + 500	10732.0 Ops/sec
Array + 1000	7096.3 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to help you understand the benchmark!

**Benchmark Definition**

The benchmark measures the performance of pushing elements onto an array in JavaScript. The test cases push arrays of different sizes (1, 10, 100, 500, and 1000 elements) onto another array.

**Options Compared**

There are two main approaches being compared:

1. **Array concatenation**: Using the `push()` method to add elements to an existing array.
2. **Spread operator**: Using the spread operator (`...`) to create a new array by spreading the elements of another array.

**Pros and Cons**

* **Array Concatenation**:
	+ Pros: Easy to understand, straightforward implementation.
	+ Cons: Can lead to performance issues due to creating multiple intermediate arrays.
* **Spread Operator**:
	+ Pros: More efficient than concatenation, creates a new array with the elements spread across it.
	+ Cons: May be less intuitive for some developers.

In general, the spread operator is considered more efficient and a better practice in modern JavaScript development.

**Library and Special JS Feature**

There is no explicit library used in this benchmark. However, it does use a special feature of JavaScript called **Rest parameter syntax** (introduced in ECMAScript 2015) which allows for the spread operator (`...`).

The Rest parameter syntax was introduced to enable more flexible function definitions and can be used with arrays to create new arrays.

**Other Considerations**

When dealing with array operations, it's essential to consider the following:

* **Memory allocation**: Creating multiple intermediate arrays can lead to performance issues due to memory allocation.
* **Cache locality**: Accessing elements in an array sequentially can improve cache locality, leading to better performance.

In this benchmark, the spread operator approach is likely to perform better than concatenation because it creates a new array with the elements spread across it, reducing the number of intermediate arrays created.

Related benchmarks:

Push performances (version: 0)

Push performances with array of 1, 10, 100, 500 and 1000 elements.

Comparing performance of: Array + 1 vs Array + 10 vs Array + 100 vs Array + 500 vs Array + 1000

Created: 4 years ago by: Guest

Jump to the latest result

Array + 1

Array + 10

Array + 100

Array + 500

Array + 1000

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