Benchmark: array filtering with some vs array filtering with includes

Script Preparation code:

var listOfObjects_1 = [{id: 1, name: '1'}, {id: 2, name: '2'}, {id: 5, name: '5'}]
var listOfObjects_2 = [{id: 1, name: '1'}, {id: 2, name: '2'}, {id: 5, name: '4'}]

Tests:

array filtering with some
listOfObjects_1.filter(selectedItem => listOfObjects_2.some(item => item.id === selectedItem.id) )
array filtering with includes
var ids_1 = listOfObjects_1.map(o => o.id) listOfObjects_2.filter(o => ids_1.includes(o.id))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array filtering with some
array filtering with includes

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.1:latest, generated one year ago):

LLMs can make mistakes. Check important info.

Let's dive into the benchmark test case.

**What is being tested?**

The test case compares two different approaches to filter an array of objects based on whether their IDs are present in another array. The goal is to determine which approach is faster.

**Approach 1: Using `some()` method**

In this approach, we use the `some()` method to check if at least one element in the second array (`listOfObjects_2`) matches the ID of each element in the first array (`listOfObjects_1`). The benchmark definition uses an arrow function to define a callback that takes an element from the first array and checks if it exists in the second array using `some()`.

**Approach 2: Using `map()` and `includes()` methods**

In this approach, we use the `map()` method to extract the IDs of all elements in the first array (`listOfObjects_1`) into a new array (`ids_1`). Then, we use the `filter()` method with the `includes()` method to filter the second array based on whether each ID exists in the extracted array.

**Pros and Cons**

Here's a brief summary:

* **Approach 1 (some())**:
	+ Pros: More concise code
	+ Cons: May have performance overhead due to the `some()` method, which is designed for iterating over an iterable until a condition is met.
* **Approach 2 (map() and includes())**:
	+ Pros: Can be faster in large datasets, as it avoids unnecessary iterations using `some()`; creates an additional array with IDs, which can be reused
	+ Cons: More verbose code; creates an additional array that needs to be managed

**Other considerations**

When choosing between these approaches:

1. **Dataset size**: For small datasets, Approach 1 might be sufficient and faster due to its conciseness.
2. **Performance requirements**: If high performance is crucial, Approach 2 (using `map()` and `includes()`) might be the better choice, as it's designed for optimized filtering in larger datasets.

**What library is used?**

None of the test cases use any external libraries other than built-in JavaScript methods like `some()`, `filter()`, `map()`, and `includes()`.

**Special JS feature or syntax?**

The only special syntax used here is arrow functions (`=>`) for defining callback functions, which are a concise way to create small functions in JavaScript.

**Other alternatives?**

For filtering an array based on whether its IDs exist in another array:

1. **Set-based approach**: Create sets from both arrays and use the intersection of those sets to filter the first array.
2. **Iterative approach**: Use nested loops or recursive function calls to manually iterate over each element in both arrays.

Keep in mind that these alternatives might be less concise than the original test cases but can provide different performance characteristics depending on your specific dataset.

Related benchmarks:

array filtering with some vs array filtering with includes (version: 0)

Return only objects with same id

Comparing performance of: array filtering with some vs array filtering with includes

Created: 5 years ago by: Guest

Jump to the latest result

array filtering with some

array filtering with includes

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model llama3.1:latest, generated one year ago):