Benchmark: Empty Array 2 - MeasureThat.net

Script Preparation code:

var arr = [];
var size = 10000;
for (var i = 0; i < size; i++) {
 	arr.push(i);    
 }

Tests:

Length to zero
arr.length = 0;
Splice
arr.splice(0);
Pop
for (var j = arr.length; j > 0; j--) { arr.pop(); }
new instance
arr = new Array();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Length to zero
Splice
Pop
new instance

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 83 on Windows

View result in a separate tab

Test name	Executions per second
Length to zero	3862691.8 Ops/sec
Splice	4776033.0 Ops/sec
Pop	7166766.5 Ops/sec
new instance	2008166.8 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark is designed to measure and compare the performance of different methods for making an empty array in JavaScript. The benchmark consists of four test cases:

1. `Length to zero`: This test case measures how long it takes to set the length of an array to 0.
2. `Splice`: This test case measures how long it takes to use the `splice(0)` method to remove the first element from an array and return it, effectively making the array empty.
3. `Pop`: This test case measures how long it takes to use a `for` loop to repeatedly pop elements from an array until it is empty.
4. `new instance`: This test case measures how long it takes to create a new empty array using the `Array()` constructor.

**Options Compared**

The benchmark compares four different approaches:

1. Using the `length` property to set the length of an array to 0 (`Length to zero`).
2. Using the `splice(0)` method to remove the first element from an array and return it (`Splice`).
3. Using a `for` loop to repeatedly pop elements from an array until it is empty (`Pop`).
4. Creating a new instance of an empty array using the `Array()` constructor (`new instance`).

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Length to zero**: This method is likely to be the fastest, as setting a property on an object is typically very fast in JavaScript. However, it may not work in older browsers that do not support dynamic property assignment.
2. **Splice**: This method is relatively fast, but it modifies the original array and returns the removed element. This can be a performance hit if you need to preserve the original data.
3. **Pop**: This method is likely to be slower than `splice`, as popping an element from an array involves searching for the element in the array and then removing it. However, it does not modify the original array.
4. **new instance**: Creating a new empty array using the `Array()` constructor is likely to be the slowest, as it involves allocating new memory.

**Libraries and Special JS Features**

There are no libraries used in this benchmark. The only special feature of JavaScript is dynamic property assignment, which allows setting a value on an object's `length` property (used in the `Length to zero` test case).

**Other Alternatives**

Some alternative approaches could be:

* Using `Array.prototype.fill(0)` to fill the array with zeros
* Using `Object.assign()` to create an empty array by assigning 0 to every index

These alternatives may not be included in the benchmark, but they are worth considering when working on similar tasks.

**Interpretation of Benchmark Results**

The benchmark results show that:

* The fastest method is using `length` property assignment (`Length to zero`) with an average execution time of around 2.5 ms per second.
* The next fastest method is using the `splice(0)` method (`Splice`) with an average execution time of around 3.7 ms per second.
* The slowest methods are using the `Pop` loop and creating a new instance of an empty array (`new instance`) with average execution times of around 5-6 ms per second.

Note that these results may vary depending on the specific browser, device platform, and operating system being tested.

Related benchmarks:

Empty Array 2 (version: 0)

Compare standards methods for making an array empty.

Comparing performance of: Length to zero vs Splice vs Pop vs new instance

Created: 4 years ago by: Registered User

Jump to the latest result

Length to zero

Splice

Pop

new instance

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