Benchmark: clearing array - MeasureThat.net

Script Preparation code:

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

Tests:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
while (array.length > 0) { array.pop(); }
while (array.pop()) {}
array.length = 0;
array = [];

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into explaining the provided JavaScript microbenchmarks.

**What is tested:**

The benchmarks measure the performance of different ways to clear an array in JavaScript. Specifically, they test:

1. Removing elements from an array using `array.pop()` and `while` loop
2. Setting the length of an array to 0 directly (`array.length = 0`)
3. Reassigning the entire array to a new empty array (`array = []`)

**Options compared:**

The benchmarks compare three different approaches:

1. **Using `while` loop with `pop()`**: This method uses a `while` loop to repeatedly remove elements from the end of the array.
2. **Using `pop()` alone**: This method directly calls the `pop()` method on the array, which also removes the last element and returns it.
3. **Directly setting length to 0**: This method simply sets the length of the array to 0.

**Pros and cons:**

1. **Using `while` loop with `pop()`**:
	* Pros: Can be more efficient for large arrays since it avoids creating a new empty array.
	* Cons: May incur additional overhead due to the loop, making it slower than other methods for small arrays.
2. **Using `pop()` alone**:
	* Pros: Simple and concise, with minimal overhead.
	* Cons: Can be less efficient for large arrays since it creates an intermediate result (the removed element).
3. **Directly setting length to 0**:
	* Pros: Very fast and efficient, as it only modifies the array's metadata.
	* Cons: May not work in all browsers or environments that don't support this syntax.

**Other considerations:**

When writing JavaScript code for performance-critical sections, consider the following:

* Use `const` and `let` instead of `var` to avoid hoisting issues.
* Avoid using `eval()` since it's slower than native code execution.
* Consider using `Array.prototype.forEach()` or other built-in methods when iterating over arrays.

**Library usage:**

None of the provided benchmark scripts explicitly use any external libraries. The focus is on measuring the performance of the JavaScript language itself.

**Special JS features or syntax:**

The benchmarks do not use any special JS features or syntax, such as async/await, promises, or modern JavaScript features like `let` and `const`.

Now that we've broken down what's being tested, let's discuss some alternatives:

* **Other clearing methods:** There are other ways to clear an array in JavaScript, such as using `splice()`, `slice()`, or even manipulating the DOM directly. These methods might have different performance characteristics.
* **Alternative browsers or environments:** The benchmarks were run on Firefox 57 with a Windows platform. Running these benchmarks on different browsers, platforms, or environments could reveal differences in performance due to implementation details or optimizations.

Keep in mind that measuring performance can be complex and influenced by many factors, including the specific use case, array size, and other variables.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:57.0) Gecko/20100101 Firefox/57.0

Browser/OS: Firefox 57 on Windows

View result in a separate tab

Test name	Executions per second
while (array.length > 0) { array.pop(); }	228277648.0 Ops/sec
while (array.pop()) {}	19190388.0 Ops/sec
array.length = 0;	35105048.0 Ops/sec
array = [];	74265104.0 Ops/sec

Related benchmarks:

clearing array (version: 0)

Comparing performance of: while (array.length > 0) { array.pop(); } vs while (array.pop()) {} vs array.length = 0; vs array = [];

Created: 6 years ago by: Guest

Jump to the latest result

while (array.length > 0) { array.pop(); }

while (array.pop()) {}

array.length = 0;

array = [];

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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