Benchmark: Array .push() vs .unshift()

Script Preparation code:

var arr = [1, 4, 2]

Tests:

.unshift()
arr.unshift(3)
.push()
arr.push(3)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
.unshift()
.push()

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Firefox 110 on Linux

View result in a separate tab

Test name	Executions per second
.unshift()	509123.5 Ops/sec
.push()	33170938.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to help you understand the benchmark and its results.

**Benchmark Overview**

The benchmark is designed to compare the performance of two JavaScript methods: `arr.push()` and `arr.unshift()`. The test creates an array `arr` with initial values `[1, 4, 2]`, then pushes or unshifts a value (`3`) onto the array. The benchmark measures how many times each operation can be executed per second.

**Script Preparation Code**

The script preparation code is:

```javascript
var arr = [1, 4, 2];
```

This creates an array `arr` with initial values `[1, 4, 2]`.

**Html Preparation Code**

There is no html preparation code provided.

**Options Compared**

Two options are compared in this benchmark:

1. `.push()`: This method appends a value to the end of the array.
2. `.unshift()`: This method inserts a value at the beginning of the array.

**Pros and Cons of Each Approach**

Here are some pros and cons of each approach:

* `.push()`:
	+ Pros: generally faster, more efficient, and widely supported.
	+ Cons: may require more memory allocations if the array is large.
* `.unshift()`: 
	+ Pros: can be faster for small arrays or when inserting at the beginning.
	+ Cons: may be slower for larger arrays or when appending.

**Library Used**

There is no explicit library used in this benchmark. The test relies on the built-in JavaScript methods `push()` and `unshift()`.

**Special JS Features or Syntax**

This benchmark does not use any special JavaScript features or syntax.

**Other Considerations**

* Memory usage: Both `.push()` and `.unshift()` have similar memory allocation patterns, but `.push()` may require more memory allocations for large arrays.
* Cache locality: The performance difference between `.push()` and `.unshift()` might be affected by cache locality. For example, when using `push()`, the CPU can load elements from cache without having to access the array's middle indices.

**Alternatives**

If you want to create a similar benchmark or test other JavaScript methods, consider using a testing framework like Jest or Mocha, which provides more advanced features and flexibility for creating custom benchmarks. Additionally, you may want to explore benchmarking libraries like Benchmark.js or micro-benchmarking frameworks that provide additional features and tools for writing high-quality benchmarks.

For example, here is an alternative benchmark definition using the Benchmark.js library:

```javascript
const b = require('benchmark');

b.add('push', function() {
  var arr = [1, 4, 2];
  while (arr.length < 10000) arr.push(3);
});

b.add('unshift', function() {
  var arr = [1, 4, 2];
  while (arr.length < 10000) arr.unshift(3);
});
```

This code creates two benchmarks using Benchmark.js: `push` and `unshift`. The tests use a loop to append or unshift values onto the array until it reaches 10,000 elements.

Related benchmarks:

Array .push() vs .unshift() | (version: 0)

Comparing performance of: .unshift() vs .push()

Created: one year ago by: Guest

Jump to the latest result

.unshift()

.push()

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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