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

Script Preparation code:

var array = [];

for(var i = 0; i < 100000; i++){array.push(Math.random());}

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
pop
shift
length
reassignment

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark data and explain what is tested, compared options, pros and cons, library usage, special JS features or syntax, and alternative approaches.

**Benchmark Definition**
The benchmark measures how fast four different methods are to clear an array with 100,000 elements. The arrays are populated with random numbers using `Math.random()` in the script preparation code.

**Comparison Options**

1. **`pop()```**: Removes and returns the last element of the array.
2. **`shift()```: Removes and returns the first element of the array.
3. **Setting `.length = 0```**: Sets the length of the array to 0, effectively clearing it.
4. **Reassigning `array = []``**: Reassigns the array to a new empty array.

**Pros and Cons**

*   **`pop()```**:
    *   Pros: Efficient for large arrays since only one element needs to be removed from the end.
    *   Cons: Can lead to memory fragmentation if not implemented carefully, as it involves shifting elements after removing the last one. This can result in inefficient use of memory.
*   **`shift()``**:
    *   Pros: Similar to `pop()` but starts with removing the first element instead of the last. It's efficient for large arrays and doesn't lead to memory fragmentation like `pop()` does when done sequentially.
    *   Cons: If implemented naively, it can be slower than using `.length = 0` for very large numbers of iterations because of potential overflows or cache behavior in JavaScript engines.
*   **`.length = 0```**:
    *   Pros: Simple and efficient since it only involves updating the array's length information. It doesn't depend on any specific element being removed, making it more likely to be implemented quickly by a JavaScript engine.
    *   Cons: May lead to an unnecessary allocation for each call if used in a loop (as seen with `for` loops), as the old elements are kept intact until they're explicitly deleted. However, this is more of a micro-optimization and generally less significant than its simplicity and speed advantages.
*   **`array = []```**:
    *   Pros: Can be particularly efficient if used at the end of a loop where it removes all previously added elements in one step without any need for subsequent deletion operations, especially when combined with `.length = 0` or another form of final array clearing.
    *   Cons: It requires reassigning the entire `array`, which can be slower than other methods since JavaScript has to perform a new allocation and copy operation.

**Library Usage**
There are no external libraries used in this benchmark. All tests rely on standard JavaScript operations provided by the engine or its libraries directly.

**Special JS Features or Syntax**

The only special feature is the use of `for...of` loop, which is a more modern way to iterate over arrays compared to traditional `for` loops with indices (`var i = 0; i < array.length; i++`). This feature was introduced in ECMAScript 2015 (ES6). Although not explicitly mentioned in the JSON data for individual test cases, it's worth noting that the script preparation code initializes an array and then populates it with random numbers using this modern loop.

Latest run results:

Run details: (Test run date: 9 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
pop	12092959.0 Ops/sec
shift	12048737.0 Ops/sec
length	8738191.0 Ops/sec
reassignment	9580482.0 Ops/sec

Related benchmarks:

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

Comparing performance of: pop vs shift vs length vs reassignment

Created: 7 years ago by: Guest

Jump to the latest result

pop

shift

length

reassignment

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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