Benchmark: Clear array via array = [] vs array.length = 0

Script Preparation code:

var list = [];
for (var i = 0; i < 1000 * 1000; i++) {
  list.push(i);
}

Tests:

array = []
list = [];
array.length = 0;
list.length = 0;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array = []
array.length = 0;

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to explain what's being tested in the provided benchmark.

**Benchmark Overview**

The benchmark is designed to compare two approaches for clearing an array: using `array = []` or `array.length = 0`. The goal is to determine which approach is faster and more efficient.

**Options Compared**

There are only two options compared:

1. **Array assignment**: Using `array = []` to create a new empty array.
2. **Array property access**: Using `array.length = 0` to set the length of an existing array to 0, effectively clearing it.

**Pros and Cons of Each Approach**

**Array Assignment (e.g., `array = []`)**

Pros:

* Creates a new empty array, which can be more efficient if the original array is large or complex.
* Can be faster since it involves creating a new object reference.

Cons:

* May involve additional memory allocation and deallocation, depending on the JavaScript engine's garbage collection behavior.
* Can be slower for very small arrays due to the overhead of creating a new object reference.

**Array Property Access (e.g., `array.length = 0`)**

Pros:

* Faster since it only involves setting a property value without creating a new object reference.
* May be more efficient for small arrays, as it avoids the overhead of creating a new array object.

Cons:

* Modifies an existing array, which can have unexpected side effects if the array is not properly cleared or validated.
* Can lead to performance issues if the array is very large or complex, since it may involve rearranging elements or copying data.

**Other Considerations**

The benchmark likely uses a JavaScript engine that has a relatively fast garbage collector, as evidenced by the high number of executions per second (e.g., 5.5M and 5.3M for each test case). This suggests that the majority of the overhead is due to the array creation process rather than garbage collection.

**Library or Framework**

The benchmark does not appear to use any external libraries or frameworks, so it's likely a simple implementation of the two approaches being compared.

**Special JavaScript Features or Syntax**

There are no special JavaScript features or syntax mentioned in the benchmark. The code uses standard JavaScript language features and syntax.

**Alternative Approaches**

Other possible ways to clear an array might include:

* Using `array.splice(0, 0)` to remove all elements from the array.
* Using a loop to remove each element individually (e.g., `for (var i = 0; i < array.length; i++) { array[i] = undefined; }`).
* Using a third-party library or framework that provides optimized array clearing functions.

However, these alternatives are not being tested in this benchmark.

Latest run results:

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

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

Browser/OS: Chrome 93 on Windows

View result in a separate tab

Test name	Executions per second
array = []	5326363.5 Ops/sec
array.length = 0;	5502964.5 Ops/sec

Related benchmarks:

Clear array via array = [] vs array.length = 0 (version: 0)

Comparing performance of: array = [] vs array.length = 0;

Created: 3 years ago by: Guest

Jump to the latest result

array = []

array.length = 0;

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