Benchmark: Lodash vs Set Intersection vs includes vs indexOf

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var first = [1, 3, 4, 5, 7];
var second = [2, 3, 5, 6];

Tests:

Lodash intersection
_.intersection(first, second)
Javascript includes
first.filter(a => second.includes(a))
Javascript indexOf
first.filter(a => second.indexOf(a) >= 0)
Javascript Set intersection
const firstSet = new Set(first); const secondSet = new Set(second); new Set([...firstSet].filter(item => secondSet.has(item)));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash intersection
Javascript includes
Javascript indexOf
Javascript Set intersection

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 14 days ago)

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

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash intersection	6104147.0 Ops/sec
Javascript includes	25087220.0 Ops/sec
Javascript indexOf	23883730.0 Ops/sec
Javascript Set intersection	5819657.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 14 days ago):

LLMs can make mistakes. Check important info.

The provided benchmark tests the performance of different methods to find the intersection of two arrays in JavaScript. Specifically, it compares four approaches: using the Lodash library, the native `Array.prototype.filter` method combined with `includes`, using `indexOf`, and leveraging the `Set` object.

### Approaches Compared

1. **Lodash intersection**:
   - **Code**: `_.intersection(first, second)`
   - **Library**: Lodash is a popular utility library in JavaScript that provides functions for programming tasks, including array manipulation, object manipulation, and function binding.
   - **Pros**: 
     - Easy to read and understand.
     - Handles various edge cases and provides additional features.
   - **Cons**: 
     - Overhead of including the Lodash library, which can result in larger bundle sizes.
     - Slower than native JavaScript as it may add overhead.

2. **JavaScript includes**:
   - **Code**: `first.filter(a => second.includes(a))`
   - **Description**: This method uses the `includes()` function to check if an element from `first` exists in `second`, returning a new array with the matching elements.
   - **Pros**: 
     - Simple and intuitive syntax.
     - Makes use of built-in JavaScript methods.
   - **Cons**: 
     - Less efficient for large arrays, as `includes` performs a linear search.

3. **JavaScript indexOf**:
   - **Code**: `first.filter(a => second.indexOf(a) >= 0)`
   - **Description**: This approach similarly filters `first`, using `indexOf()` to check for the existence of elements in `second`.
   - **Pros**: 
     - Also utilizes native JavaScript methods, making it straightforward.
   - **Cons**: 
     - Like `includes`, it requires traversing the full `second` array for each element from `first`, which can lead to performance issues as data sizes grow.

4. **JavaScript Set intersection**:
   - **Code**: 
     ```javascript
     const firstSet = new Set(first);
     const secondSet = new Set(second);
     new Set([...firstSet].filter(item => secondSet.has(item)));
     ```
   - **Description**: This method converts the arrays into `Set` objects, allowing for quick lookups via the `has` method, thus filtering out the intersection.
   - **Pros**: 
     - Set operations provide average O(1) complexity for lookups, greatly improving performance compared to the other methods for large datasets.
     - Reduces redundancy by removing duplicate elements from the original arrays.
   - **Cons**: 
     - Slightly more complex syntax, which may not be as readable for those unfamiliar with `Set`.
     - Introduces additional memory overhead due to storing data in `Set` objects.

### Summary of Results

From the performance results, it appears that the `Array.prototype.includes` method achieved the highest executions per second, followed closely by `indexOf`, while both the Lodash intersection and `Set` intersection performed significantly slower. This suggests that while utility libraries like Lodash provide developer-friendly syntax and robust functionality, they can come at a performance cost.

### Alternative Approaches

Besides these methods, other alternatives can be considered for intersecting arrays in JavaScript:

- **Using `Map` for frequency counting**: An approach using a `Map` to count occurrences of elements across both arrays can also be efficient, especially for larger datasets.
- **Using external libraries**: Libraries like Ramda or even the native array methods combined with functional programming paradigms can also yield more versatile solutions.

In conclusion, each method has trade-offs in terms of performance, readability, and ease of use. The choice of approach will depend on the specific use case, dataset size, and performance requirements of the project.

Related benchmarks:

Lodash vs Set Intersection vs includes vs indexOf (version: 1)

Comparing performance of: Lodash intersection vs Javascript includes vs Javascript indexOf vs Javascript Set intersection

Created: 14 days ago by: Guest

Jump to the latest result

Lodash intersection

Javascript includes

Javascript indexOf

Javascript Set intersection

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 14 days ago):