Benchmark: Empty an array in JavaScript

Script Preparation code:

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

Tests:

Instantiate new array
var a1 = JSON.parse(JSON.stringify(a)); a1 = [];
Set length to zero
var a2 = JSON.parse(JSON.stringify(a)); a2.length = 0;
Splice at index zero
var a3 = JSON.parse(JSON.stringify(a)); a3.splice(0, a3.length);
Pop all values
var a4 = JSON.parse(JSON.stringify(a)); while(a4.length > 0){ a4.pop(); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Instantiate new array
Set length to zero
Splice at index zero
Pop all values

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 134 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Instantiate new array	101.0 Ops/sec
Set length to zero	101.9 Ops/sec
Splice at index zero	101.4 Ops/sec
Pop all values	99.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark is designed to measure how fast JavaScript can empty an array of 100,000 random numbers. There are four different approaches:

1. **Instantiate a new array**: Create a new array and assign it to the variable `a1`.
2. **Set length to zero**: Set the length property of the existing array `a` to 0.
3. **Splice at index zero**: Use the `splice()` method with an empty array and the first element as arguments (0 and `a.length`).
4. **Pop all values**: Use a while loop to pop elements from the end of the array until it's empty.

**Approach Comparison**

Each approach has its pros and cons:

1. **Instantiate new array**:
	* Pros: Fast and efficient, as it creates a new array without modifying the original one.
	* Cons: Creates an additional object in memory, which can be problematic for large arrays.
2. **Set length to zero**:
	* Pros: Modifies the original array in place, reducing memory usage.
	* Cons: Can be slower than creating a new array, as it modifies the existing array's properties.
3. **Splice at index zero**:
	* Pros: Modifies the original array in place and can be faster than setting length to zero.
	* Cons: Requires a separate array object creation and copying, which adds overhead.
4. **Pop all values**:
	* Pros: In-place modification and potentially efficient for large arrays.
	* Cons: Slower than creating a new array or setting length to zero due to the use of loops.

**Library and Special JS Features**

In this benchmark, the library used is `JSON.parse()`, which is a built-in JavaScript function. Its purpose is to parse JSON strings into JavaScript objects. However, in this case, it's being used to create a deep copy of the array using the `JSON.parse(JSON.stringify())` syntax.

There are no special JS features used in this benchmark.

**Test Results**

The latest test results show that:

1. **Set length to zero**: The fastest approach with 57.88 executions per second.
2. **Instantiate new array**: Second-fastest with 57.75 executions per second.
3. **Splice at index zero**: Third-fastest with 55.58 executions per second.
4. **Pop all values**: Slowest with 53.62 executions per second.

**Alternatives**

If you wanted to modify this benchmark, here are some alternatives:

1. Use a different array size or distribution (e.g., random integers, strings).
2. Introduce additional operations within the loop (e.g., push, slice, filter).
3. Compare performance with other JavaScript engines or versions.
4. Measure memory usage and garbage collection overhead for each approach.

Keep in mind that the results may vary depending on the specific use case and system configuration.

Related benchmarks:

Empty an array in JavaScript (version: 0)

Given an array of 100,000 random numbers, is it faster to empty the array by instantiating a new array, setting its length to zero, splicing it at index zero, or popping all values?

Comparing performance of: Instantiate new array vs Set length to zero vs Splice at index zero vs Pop all values

Created: 2 years ago by: Guest

Jump to the latest result

Instantiate new array

Set length to zero

Splice at index zero

Pop all values

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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