Benchmark: Empty an array in JavaScript (with baseline)

Empty an array in JavaScript (with baseline) (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 vs JSON.parse baseline

Created: one year ago by: Guest

Jump to the latest result

Script Preparation code:

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

Tests:

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

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
JSON.parse baseline

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmark that measures the performance of different approaches to empty an array of 100,000 random numbers.

**Benchmark Definition**

The benchmark definition is as follows:

* Create an array of 100,000 random numbers using a `for` loop.
* Empty the array by one of four methods:
	+ Instantiating a new array and assigning it to the original variable (`var a1 = JSON.parse(json); a1 = [];`)
	+ Setting the length of the array to zero using the dot notation (`var a2 = JSON.parse(json); a2.length = 0;`)
	+ Using `splice` to remove elements from the beginning of the array (`var a3 = JSON.parse(json); a3.splice(0, a3.length);`)
	+ Looping through the array and popping each element using a `while` loop (`var a4 = JSON.parse(json); while(a4.length > 0){a4.pop();}`)
* Compare the performance of these four methods.

**Options Compared**

The benchmark compares the performance of four different approaches to empty an array:

1. **Instantiate new array**: Create a new array and assign it to the original variable (`var a1 = JSON.parse(json); a1 = [];`)
2. **Set length to zero**: Set the length of the array to zero using the dot notation (`var a2 = JSON.parse(json); a2.length = 0;`)
3. **Splice at index zero**: Use `splice` to remove elements from the beginning of the array (`var a3 = JSON.parse(json); a3.splice(0, a3.length);`)
4. **Pop all values**: Loop through the array and pop each element using a `while` loop (`var a4 = JSON.parse(json); while(a4.length > 0){a4.pop();}`)

**Pros and Cons of Each Approach**

* **Instantiate new array**: This approach creates a new array object, which can be slower than modifying the original array. However, it avoids the potential issues with modifying an array in place.
	+ Pros: avoids modifying the original array, faster for some use cases
	+ Cons: creates a new array object, may not be suitable for all use cases
* **Set length to zero**: This approach modifies the original array in place and is typically faster than creating a new array. However, it can lead to issues if the array contains references or other complex data structures.
	+ Pros: fast, efficient, and easy to implement
	+ Cons: may cause issues with modifying an array in place, requires caution when using references or complex data structures
* **Splice at index zero**: This approach uses `splice` to remove elements from the beginning of the array. It is similar to setting the length to zero but avoids the potential issues with modifying an array in place.
	+ Pros: faster than creating a new array, easier to implement than setting the length to zero
	+ Cons: may not be suitable for all use cases (e.g., if the array contains references or complex data structures)
* **Pop all values**: This approach loops through the array and pops each element using a `while` loop. It can lead to issues with modifying an array in place.
	+ Pros: avoids modifying an array in place, may be suitable for certain use cases
	+ Cons: slower than other approaches, may cause issues if the array contains references or complex data structures

**Library Used**

The benchmark uses `JSON.parse` to create a new JavaScript object from a JSON string. This is used as a baseline comparison for the four emptying methods.

**Special JS Feature/Syntax**

None of the benchmark test cases use special JS features or syntax that require additional explanation.

**Other Alternatives**

If you need to empty an array in JavaScript, consider using one of the following alternatives:

* `Array.prototype.fill()`: This method fills all elements of an array with a specified value. It can be used to clear an array by setting its length to zero.
* `Array.prototype.slice()`: This method creates a shallow copy of a portion of an array. It can be used to create a new array that contains the same elements as the original array, but it does not modify the original array.

In summary, the benchmark compares four different approaches to empty an array in JavaScript: instantiating a new array, setting the length to zero, using `splice` at index zero, and looping through the array and popping each element. Each approach has its pros and cons, and the choice of method depends on the specific use case and requirements.

Latest run results:

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

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

Browser/OS: Firefox 115 on Windows

View result in a separate tab

Test name	Executions per second
Instantiate new array	105.9 Ops/sec
Set length to zero	107.2 Ops/sec
Splice at index zero	116.0 Ops/sec
Pop all values	110.4 Ops/sec
JSON.parse baseline	108.7 Ops/sec

Related benchmarks:

Empty an array in JavaScript (with baseline) (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 vs JSON.parse baseline

Created: one year ago by: Guest

Jump to the latest result

Instantiate new array

Set length to zero

Splice at index zero

Pop all values

JSON.parse baseline

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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