Benchmark: Shift/Pop - MeasureThat.net

Script Preparation code:

window.n = 100000;

Tests:

shift
arr = Array.from(new Array(n)).map((_,i)=>i) for(let i = 0; i < n; i++){ arr.shift() }
pop
arr = Array.from(new Array(n)).map((_,i)=>i) for(let i = 0; i < n; i++){ arr.pop() }
splice(shift)
arr = Array.from(new Array(n)).map((_,i)=>i) for(let i = 0; i < n; i++){ arr.splice(0, 1) }
splice(pop)
arr = Array.from(new Array(n)).map((_,i)=>i) for(let i = 0; i < n; i++){ arr.splice(n-i-1, 1) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
shift
pop
splice(shift)
splice(pop)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
shift	2.1 Ops/sec
pop	40.4 Ops/sec
splice(shift)	1.9 Ops/sec
splice(pop)	25.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks and analyze the provided benchmark.

**Benchmark Definition**

The benchmark definition is an object that represents a specific test case. In this case, we have four benchmark definitions:

1. "Shift/Pop"
2. Shift
3. Splice(shift)
4. Splice(pop)

Each benchmark definition has three properties: `Name`, `Description`, and two code snippets: `Script Preparation Code` and `Html Preparation Code`. The `Name` property provides a human-readable name for the benchmark, while the `Description` property is empty in this case.

**Script Preparation Code**

The `Script Preparation Code` snippet sets a global variable `n` to 100,000. This variable will be used throughout the test cases. In JavaScript, variables are scoped to the surrounding function or block, so setting `n` globally makes it accessible to all code within the script preparation code.

**Html Preparation Code**

The `Html Preparation Code` snippet is empty, which means that no additional HTML elements are prepared for this benchmark.

**Individual Test Cases**

We have four test cases:

1. **Shift**
	* Benchmark Definition: `arr = Array.from(new Array(n)).map((_,i)=>i)\r\nfor(let i = 0; i < n; i++){\r\n  arr.shift()\r\n}`
	* Purpose: This benchmark tests the performance of the `shift()` method on an array. The `Array.from` constructor creates a new array with `n` elements, each initialized to its index using the arrow function `( (_,i)=>i )`. Then, for each element in the array, the `shift()` method is called.
2. **Pop**
	* Benchmark Definition: Same as Shift
	* Purpose: This benchmark tests the performance of the `pop()` method on an array. The code is identical to the Shift benchmark, but uses the `pop()` method instead of `shift()`.
3. **Splice(shift)**
	* Benchmark Definition: `arr = Array.from(new Array(n)).map((_,i)=>i)\r\nfor(let i = 0; i < n; i++){\r\n  arr.splice(0, 1)\r\n}`
	* Purpose: This benchmark tests the performance of the `splice()` method with a shift-like operation. The `splice` method is called on the array with an offset of 0 and a count of 1.
4. **Splice(pop)**
	* Benchmark Definition: Same as Splice(shift)
	* Purpose: This benchmark tests the performance of the `splice()` method with a pop-like operation. The code is identical to the Splice(shift) benchmark, but uses the `pop()` method instead of `shift()`.

**Library Usage**

The `Array.from` constructor and the `splice` method are part of the JavaScript standard library. These methods are built-in functions that provide efficient array creation and manipulation.

**Special JS Features/Syntax**

There is no special JavaScript feature or syntax used in this benchmark. The code only uses standard JavaScript constructs, such as loops, arrays, and global variables.

**Pros and Cons**

Here's a brief summary of the pros and cons for each approach:

1. **Shift**: Fastest execution time due to caching of array elements.
	* Pros: Faster execution times
	* Cons: Only applicable when `shift()` is used explicitly
2. **Pop**: Similar performance to Shift, but with slightly higher overhead due to extra iteration.
	* Pros: Still relatively fast
	* Cons: Slightly slower than Shift
3. **Splice(shift)**: Uses a more complex operation that can be slower than using shift() directly.
	* Pros: Allows for more control over array manipulation
	* Cons: Generally slower execution times
4. **Splice(pop)**: Similar performance to Splice(shift), but with extra overhead due to the `pop()` method.
	* Pros: Still relatively fast
	* Cons: Slightly slower than Shift

**Other Alternatives**

If you want to compare the performance of other array methods, consider adding more test cases for:

* `unshift()`
* `slice()`
* `concat()`
* `reverse()`
* `sort()`

Keep in mind that each method has its own use case and optimization opportunities.

Related benchmarks:

Shift/Pop (version: 2)

Comparing performance of: shift vs pop vs splice(shift) vs splice(pop)

Created: 4 years ago by: Registered User

Jump to the latest result

shift

pop

splice(shift)

splice(pop)

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