Benchmark: FindIndex + splice vs filter

Script Preparation code:

var arr = new Array(15000);
arr.fill({ id: 0 });
arr = arr.map((el, idx) => el.id = idx);
var foo = Math.floor(Math.random() * 15000);

Tests:

FindIndex + splice
var index = arr.indexOf(foo); var newArr = arr.splice(index, 1);
filter
var index = arr.filter(el => el !== foo)

Historical Performance Data aggregated from 115 community runs

Desktop Results:

Chrome 101 runs

filter

25.7M/s

FindIndex + splice

8.8M/s

Fastest: filter (2.9x faster)

View exact numbers

✓ filter: 25,715,654 ops/sec
• FindIndex + splice: 8,842,681 ops/sec

Firefox 14 runs

filter

196.0M/s

FindIndex + splice

27.4M/s

Fastest: filter (7.2x faster)

View exact numbers

✓ filter: 195,983,712 ops/sec
• FindIndex + splice: 27,360,552 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
FindIndex + splice
filter

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 18 minutes ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36

Browser/OS: Chrome 151 on Linux

View result in a separate tab

filter

222.1M/s

FindIndex + splice

75.2M/s

View exact numbers

Test name	Executions per second
✓ filter	222,097,168 Ops/sec
FindIndex + splice	75,240,952 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared options, pros and cons, and other considerations.

**Benchmark Overview**

The provided benchmark compares two approaches to remove an element from an array:

1. `FindIndex + splice`: Using `indexOf` to find the index of the element to be removed and then using `splice` to remove it.
2. `filter`: Using the `filter` method to create a new array with elements that do not match the specified condition.

**Benchmark Definition JSON**

The benchmark definition JSON contains two test cases:

* `FindIndex + splice`: This test case uses the `indexOf` method to find the index of the element to be removed and then uses `splice` to remove it.
* `filter`: This test case uses the `filter` method to create a new array with elements that do not match the specified condition.

**Options Compared**

The benchmark compares two approaches:

1. `FindIndex + splice`
2. `filter`

**Pros and Cons of Each Approach**

### FindIndex + splice

Pros:

* Efficient use of memory, as only one element needs to be removed from the original array.
* Can be faster for large arrays due to the optimized implementation of `indexOf` and `splice`.

Cons:

* Requires two operations: finding the index and then removing the element. This can lead to overhead due to the repeated calls to `indexOf`.
* May not be as efficient as other methods, such as `filter`, for very large datasets.

### filter

Pros:

* Creates a new array with elements that do not match the specified condition, avoiding mutation of the original array.
* Can be faster for very large datasets, as it uses a more efficient algorithm that avoids repeated calls to `indexOf`.

Cons:

* Requires additional memory to store the new array.
* May be slower than `FindIndex + splice` for smaller arrays due to the overhead of creating and populating the new array.

**Other Considerations**

* The benchmark does not consider other approaches, such as using `some()` or `every()`, which could also be used to filter an array.
* The benchmark does not account for edge cases, such as an empty array or an array with only one element.
* The use of `Math.random()` in the script preparation code introduces randomness, which can affect the results and make the benchmark less accurate.

**Library Used**

In this case, no specific library is used. However, if a library like Lodash were to be used, it might provide additional features or optimizations for array manipulation.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntaxes being used in this benchmark.

**Alternatives**

Other alternatives for removing an element from an array include:

* Using `splice` with a single argument (e.g., `arr.splice(0, 1)`).
* Using `map()` and `reduce()` to create a new array.
* Using `every()` or `some()` to filter the array.

Keep in mind that these alternatives may have different performance characteristics and trade-offs compared to the approaches being tested in this benchmark.

FindIndex + splice vs filter (version: 0)

Comparing performance of: `FindIndex + splice vs filter`

Created: 5 years ago by: Guest

Go to the latest result

FindIndex + splice

filter

Historical Performance Data aggregated from 115 community runs

Desktop Results:

Chrome 101 runs

Firefox 14 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

FindIndex + splice vs filter (version: 0)

Comparing performance of: FindIndex + splice vs filter

Created: 5 years ago by: Guest

Go to the latest result

FindIndex + splice

filter

Historical Performance Data aggregated from 115 community runs

Desktop Results:

Chrome 101 runs

Firefox 14 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `FindIndex + splice vs filter`