Benchmark: empty an array in JavaScript?

Script Preparation code:

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

Tests:

Just instantiate new array
var arr = Array.from(origArr); arr = [];
Set length to zero
var arr = Array.from(origArr); arr.length = 0;
Splice
var arr = Array.from(origArr); arr.splice(0, arr.length);
Pop all values
var arr = Array.from(origArr); while(arr.length > 0){ 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

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases.

**Benchmark Definition**

The benchmark measures how quickly JavaScript can empty an array. The description links to a Stack Overflow question asking for the best way to clear an array in JavaScript. The script preparation code creates an original array `origArr` with 10,000 elements using a simple loop.

**Comparison of Options**

Three options are compared:

1. **Just instantiate a new array**: Creates a new array `arr` and assigns it the result of calling `Array.from(origArr)`. Then, immediately sets `arr` to an empty array.
2. **Set length to zero**: Creates a new array `arr` using `Array.from(origArr)` and then sets its length to 0 directly.
3. **Splice**: Creates a new array `arr` using `Array.from(origArr)` and then uses the `splice()` method to remove all elements from the start of the array ( indices 0 to `arr.length - 1`).
4. **Pop all values**: Creates a new array `arr` using `Array.from(origArr)` and then uses a `while` loop to pop each element from the end of the array until there are no more elements left.

**Pros and Cons**

* **Just instantiate a new array**:
	+ Pros: Simple, easy to understand.
	+ Cons: Creates an unnecessary intermediate array.
* **Set length to zero**:
	+ Pros: Directly sets the length to 0, avoids creating an intermediate array.
	+ Cons: May not be as efficient as other methods for large arrays due to the overhead of setting a property on an object.
* **Splice**:
	+ Pros: Efficiently removes all elements from the start of the array without creating an unnecessary intermediate array.
	+ Cons: Can be slower than other methods if only a single element needs to be removed, as it involves shifting all subsequent elements.
* **Pop all values**:
	+ Pros: Can be efficient for large arrays since it avoids creating an intermediate array and uses built-in JavaScript functionality ( popping elements is a low-cost operation).
	+ Cons: May not be suitable for small arrays due to the overhead of the `while` loop.

**Library Used**

None explicitly mentioned. However, `Array.from()` is a method on the global `Array` prototype, which is an array-like object and not strictly a library.

**Special JS Features/Syntax**

* None explicitly mentioned.

**Other Considerations**

When comparing these options, it's essential to consider the size of the input data (`origArr`) and the specific requirements of the use case. For small arrays, creating a new array using `Array.from()` might be sufficient, but for large arrays or performance-critical code, the optimized methods (e.g., setting length to 0 or using `splice()`) may provide better results.

**Alternatives**

Other alternatives to clear an array in JavaScript include:

* Using the `length` property directly: `arr.length = 0;`
* Using a combination of `Array.prototype.slice()` and assignment: `var arr = arr.slice(0); arr = [];`
* Using `Object.assign(arr, []);`: This method is not as efficient as other methods but can be used in some specific situations.

Keep in mind that these alternatives might have different performance characteristics depending on the JavaScript engine, browser, or specific use case.

Latest run results:

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

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

Browser/OS: Firefox 59 on Windows

View result in a separate tab

Test name	Executions per second
Just instantiate new array	3362.5 Ops/sec
Set length to zero	2672.2 Ops/sec
Splice	3260.2 Ops/sec
Pop all values	1938.2 Ops/sec

Related benchmarks:

empty an array in JavaScript? (version: 1)

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: 6 years ago by: Registered User

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 26 days ago):