Benchmark: empty arrays - MeasureThat.net

Script Preparation code:

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

Tests:

Just instantiate new array
arr = [];
Set length to zero
arr.length = 0;
Splice
arr.splice(0, arr.length);
Pop all values
while(arr.length) { arr.pop(); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Just instantiate new array
Set length to zero
Splice
Pop all values

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 96 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Just instantiate new array	12656490.0 Ops/sec
Set length to zero	9843802.0 Ops/sec
Splice	6935257.0 Ops/sec
Pop all values	16758352.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark measures how fast different approaches are to empty an array in JavaScript. The "empty arrays" benchmark checks the performance of various methods to clear or reset the length of an array.

**Benchmark Preparation Code**

The script preparation code creates a large array with 10,000 elements, all initialized with incremental values from 0 to 9,999.

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

**HTML Preparation Code**

There is no HTML preparation code provided, which means the benchmark focuses solely on JavaScript performance.

**Individual Test Cases**

The benchmark consists of four test cases:

1. **Just instantiate a new array**: This test case creates a new array using the `var arr = [];` syntax.
2. **Set length to zero**: This test case uses the `arr.length = 0;` syntax to set the length of the existing array to zero.
3. **Splice**: This test case uses the `arr.splice(0, arr.length);` syntax to remove all elements from the beginning of the array.
4. **Pop all values**: This test case uses a while loop to pop all elements from the end of the array.

**Library and Special JS Features**

None of the benchmark tests use any external libraries or special JavaScript features. The performance comparison is solely based on the different methods used to empty the arrays.

**Comparison of Approaches**

The four approaches can be compared as follows:

* **Just instantiate a new array**: This approach creates a new, empty array and assigns it to `arr`. It's likely to be the fastest method since it involves minimal work.
* **Set length to zero**: This approach modifies the existing array by setting its length to zero. While this is simple, it might incur some overhead due to the need to update internal array structures.
* **Splice**: This approach removes all elements from the beginning of the array using `arr.splice(0, arr.length);`. It's likely to be slower than the other two methods since it involves more work and potentially updating multiple indices.
* **Pop all values**: This approach uses a while loop to pop all elements from the end of the array. While this is an efficient way to clear the array, it might be slower due to the need to repeatedly check and update the length property.

**Pros and Cons**

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

* **Just instantiate a new array**:
	+ Pros: Fast, simple, and easy to understand.
	+ Cons: Creates a new object in memory, which might be unnecessary if not needed.
* **Set length to zero**:
	+ Pros: Modifies the existing array, reducing memory allocation.
	+ Cons: May incur overhead due to updating internal structures.
* **Splice**:
	+ Pros: Efficiently removes elements from the beginning of the array.
	+ Cons: Involves more work and potentially updates multiple indices.
* **Pop all values**:
	+ Pros: Efficiently clears the array, reducing memory usage.
	+ Cons: Requires repeated checks and updates to the length property.

**Other Alternatives**

If you need to empty an array in JavaScript, consider these alternatives:

* `arr.length = 0;` (set length to zero)
* `arr.splice(0);` (remove all elements from the beginning of the array)
* Using a `for...in` loop or `forEach` method to iterate over the array and remove elements
* Using a library like Lodash (`_.uniq`) or Ramda (`R.remove`) with an empty function

Keep in mind that performance may vary depending on the specific use case, array size, and JavaScript environment.

I hope this explanation helps you understand what's being tested and compared in the "empty arrays" benchmark!

Related benchmarks:

empty arrays (version: 0)

Based on question on http://stackoverflow.com/questions/1232040/how-do-i-empty-an-array-in-javascript

Comparing performance of: Just instantiate new array vs Set length to zero vs Splice vs Pop all values

Created: 2 years ago by: Guest

Jump to the latest result

Just instantiate new array

Set length to zero

Splice

Pop all values

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