Benchmark: Array filtering: (splice + predefined index) vs (filter) - small array

Script Preparation code:

var arr1 = new Array(100).fill(0);
var arr2 = new Array(100).fill(0);
var indexesToDelete = [3, 10, 40, 60, 70, 90];

indexesToDelete.forEach(index => {
	arr1[index] = 1;
  	arr2[index] = 1;
});

Tests:

splice
indexesToDelete.forEach(index => { arr1.splice(index, 1); });
filter
const newArr = arr2.filter(value => value !== 1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
splice
filter

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
splice	11149829.0 Ops/sec
filter	3870210.5 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 benchmarking tests and analyze what's being tested.

**Benchmark Definition**

The first section of the JSON represents a benchmark definition, which outlines the test to be performed. In this case, there are two benchmarks:

1. `Array filtering: (splice + predefined index) vs (filter) - small array`
2. Two individual test cases:
	* `splice`
	* `filter`

The first benchmark compares two approaches for filtering an array: using `splice()` with a predefined index and using the `filter()` method.

**Options Compared**

Two options are being compared:

1. **`splice()`**: A JavaScript method that removes or replaces elements in an array.
2. **`filter()`**: A JavaScript method that creates a new array with all elements that pass a provided test.

**Pros and Cons of Each Approach**

Here's a brief analysis of the pros and cons of each approach:

**`splice()`**

Pros:

* Can be efficient for small arrays, as it only iterates over a subset of elements.
* Allows for fine-grained control over which elements to remove or replace.

Cons:

* Can be slow for large arrays, as it needs to iterate over the entire array.
* Can cause shifting of subsequent elements if elements are removed from the middle of the array.

**`filter()`**

Pros:

* Efficiently handles large arrays by only iterating over the elements that need to be filtered.
* Does not shift subsequent elements when removing or replacing elements.

Cons:

* May have higher overhead due to function call and object creation.

**Library Usage**

There is no explicit library usage in this benchmark, but `filter()` uses a built-in JavaScript method. However, for completeness, the `filter()` method relies on the following internal functions:

* `Array.prototype.filter()`: Creates a new array with all elements that pass a provided test.
	+ Implemented using `Array.prototype.forEach()`, which iterates over the array and calls the callback function for each element.

**Special JS Features**

There is no explicit usage of special JavaScript features in this benchmark, such as async/await, Promises, or generators. If there were any additional features, they would likely be mentioned in the `Script Preparation Code` or `Html Preparation Code`.

**Other Alternatives**

If you're interested in exploring alternative approaches for array filtering, consider the following:

1. **Using `map()` and `slice()`:** This approach can be more efficient than using `splice()` or `filter()`, but may have higher overhead due to the creation of new arrays.
2. **Using a library like Lodash:** Lodash provides a `filterBy` function that can be used for array filtering, which might offer better performance and readability compared to built-in JavaScript methods.

Keep in mind that these alternatives would require additional setup and testing, but they might provide valuable insights into different approaches to array filtering.

Related benchmarks:

Array filtering: (splice + predefined index) vs (filter) - small array (version: 0)

Comparing performance of: splice vs filter

Created: 3 years ago by: Registered User

Jump to the latest result

splice

filter

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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