Benchmark: clearing array via pop() vs shift() vs .length = 0 vs = [] - fix

Script Preparation code:

// var array = Array(100000);

// for(var i = 0; i < 10000000; i++){array.push(Math.random());}

Tests:

pop
var array = Array(100000); while (array.length > 0) { array.pop(); }
shift
var array = Array(100000); while (array.length > 0) { array.shift(); }
length
var array = Array(100000); array.length = 0
reassignment
var array = Array(100000); array = []
.splice(0)
var array = Array(100000); array.splice(0);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
pop
shift
length
reassignment
.splice(0)

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 112 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
pop	5487.0 Ops/sec
shift	2.7 Ops/sec
length	16661.1 Ops/sec
reassignment	16345.1 Ops/sec
.splice(0)	8748.6 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is tested?**

The provided benchmark tests four different ways to clear an array in JavaScript:

1. `pop()`: Removing elements from the end of the array using the `pop()` method.
2. `shift()`: Removing the first element from the array using the `shift()` method.
3. `length = 0` or simply setting the length property of the array to 0.
4. `array = []`: Reassigning the entire array to an empty array.

**Options compared**

Each test case compares the performance of one specific approach against others, which can be seen as alternatives:

* `pop()` vs `shift()`
* `pop()` vs `length = 0`
* `pop()` vs `reassignment` (i.e., setting the entire array to an empty array)
* `shift()` vs `length = 0`
* `shift()` vs `reassignment`
* `length = 0` vs `reassignment`

**Pros and Cons of each approach**

Here's a brief summary:

1. **pop()**: Efficient way to remove elements from the end of an array, as it only removes one element at a time.
	* Pros: Fast performance, easy to use.
	* Cons: Can lead to frequent array resizing if not optimized.
2. **shift()**: Efficient way to remove the first element of an array, but can be slower than `pop()` for large arrays.
	* Pros: Allows efficient removal of elements from the beginning of the array.
	* Cons: Slower performance compared to `pop()`, especially for large arrays.
3. **length = 0**: Setting the length property of the array directly to 0.
	* Pros: Fast and memory-efficient way to clear an array, as it doesn't create a new array object.
	* Cons: Can be slower than `push()` or `unshift()` if used in loops, as it requires updating the internal array size.
4. **Reassignment (array = [])**: Reassigning the entire array to an empty array using the assignment operator.
	* Pros: Simple and readable way to clear an array, especially when combined with other methods like `push()` or `shift()`.
	* Cons: Can be slower than setting `length` directly, as it creates a new array object.

**Other considerations**

In modern JavaScript, the use of `Array.prototype.slice()` (not shown in this benchmark) can also provide efficient ways to clear an array by creating a shallow copy and then discarding the original array. However, it's not included in this specific benchmark.

When choosing an approach, consider factors like:

* Performance: `pop()` or `shift()` are generally faster than setting `length` directly.
* Readability: Reassignment (using `array = []`) can be a simple and readable way to clear an array.
* Memory usage: `length = 0` is memory-efficient, as it doesn't create a new array object.

**Alternatives**

Some alternative approaches not included in this benchmark include:

* Using `Array.prototype.fill()` or `Array.prototype.splice()` with large numbers of elements.
* Implementing custom clearing logic using bitwise operations (e.g., setting all elements to 0).
* Using specialized libraries or frameworks that optimize array manipulation for performance-critical applications.

Keep in mind that the choice of approach depends on the specific use case, such as performance requirements, readability concerns, and potential limitations in older browsers.

Related benchmarks:

clearing array via pop() vs shift() vs .length = 0 vs = [] - fix (version: 0)

Comparing performance of: pop vs shift vs length vs reassignment vs .splice(0)

Created: one year ago by: Guest

Jump to the latest result

pop

shift

length

reassignment

.splice(0)

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