Benchmark: Removing from array of objects by property

Script Preparation code:

arr = [{a: 1, b: 20}, {a: "c", b: 20}]

Tests:

findItem + splice
idx = arr.findIndex(o => o.a === 'c') arr.splice(idx, 1)
reassignement & filter
arr = arr.filter(o => o.a !== 'c')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
findItem + splice
reassignement & filter

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases to understand what is being tested.

**Benchmark Definition:**
The benchmark is testing two approaches for removing an item from an array of objects by property:

1. Using `findIndex` and `splice`: This approach involves finding the index of the item in the array using the `findIndex` method, which returns the lowest index at which this value can be found in the array. Once the index is found, the `splice` method is used to remove the item from the array.
2. Using `filter` and reassignment: This approach involves creating a new array that includes only the items that do not match the specified condition using the `filter` method. The resulting filtered array is then reassigned back to the original variable.

**Options Compared:**
The benchmark is comparing the performance of these two approaches:

* `findItem & splice`: Uses `findIndex` and `splice`
* `reassignement & filter`: Uses `filter` and reassignment

**Pros and Cons:**

* **FindItem & Splice**:
	+ Pros:
		- Can be more efficient for large arrays, as it only requires finding the index of the item once.
		- Can be less memory-intensive, as it only creates a new array with the filtered items.
	+ Cons:
		- Requires calling `findIndex` and `splice`, which can be slower than a single method call.
		- May require more code and is more prone to errors due to the additional step of finding the index.
* **Reassignement & Filter**:
	+ Pros:
		- Can be simpler to implement, as it only requires creating a new array using `filter`.
		- Can be less error-prone, as it only involves a single method call.
	+ Cons:
		- May require more memory, as it creates a new array with the filtered items.
		- Can be slower for large arrays, as it requires iterating over all items in the original array.

**Library/Functionality Used:**
None of the provided benchmark test cases use any external libraries. However, they do utilize JavaScript's built-in methods:

* `findIndex`: Returns the lowest index at which this value can be found in the array.
* `splice`: Removes the item at the specified index from the array.
* `filter`: Creates a new array that includes only the items that pass the test.

**Special JS Feature/Syntax:**
The benchmark uses a feature of JavaScript called "Arrow Functions" (`o => o.a === 'c'`), which is used as the callback function in the `findIndex` and `filter` methods. Arrow functions are a concise way to define small, single-expression functions. They were introduced in ECMAScript 2015 (ES6) and provide a more concise syntax for defining functions.

**Alternatives:**
Other alternatives for removing an item from an array of objects by property could include:

* Using `map` and then slicing the resulting array
* Using `forEach` and pushing or splicing the result into a new array
* Using a library like Lodash, which provides a `filterBy` method for filtering arrays

It's worth noting that the best approach will depend on the specific use case and performance requirements.

Latest run results:

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

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

Browser/OS: Chrome 79 on Mac OS X 10.13.6

View result in a separate tab

Test name	Executions per second
findItem + splice	1137923.1 Ops/sec
reassignement & filter	2148896.2 Ops/sec

Related benchmarks:

Removing from array of objects by property (version: 0)

findItem & splice VS filter & reassignement

Comparing performance of: findItem + splice vs reassignement & filter

Created: 4 years ago by: Guest

Jump to the latest result

findItem + splice

reassignement & filter

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