Benchmark: Lodash vs Set Intersection vs includes vs indexOf (not ordered list)

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 = [
  { "key": "Alice" },
  { "key": "Bob" },
  { "key": "Charlie" },
  { "key": "David" },
  { "key": "Eve" },
  { "key": "Frank" },
  { "key": "Grace" },
  { "key": "Hannah" },
  { "key": "Ivy" },
  { "key": "Jack" },
  { "key": "Kathy" },
  { "key": "Leo" },
  { "key": "Mona" },
  { "key": "Nina" },
  { "key": "Oscar" },
  { "key": "Paul" },
  { "key": "Quincy" },
  { "key": "Rita" },
  { "key": "Sam" },
  { "key": "Tina" },
  { "key": "Uma" },
  { "key": "Victor" },
  { "key": "Wendy" },
  { "key": "Xander" },
  { "key": "Yara" },
  { "key": "Zach" },
  { "key": "Ava" },
  { "key": "Liam" },
  { "key": "Noah" },
  { "key": "Emma" },
  { "key": "Olivia" },
  { "key": "Sophia" },
  { "key": "Jackson" },
  { "key": "Lucas" },
  { "key": "Mason" },
  { "key": "Ethan" },
  { "key": "Aiden" },
  { "key": "Logan" },
  { "key": "Zoe" },
  { "key": "Chloe" },
  { "key": "Lily" },
  { "key": "Ella" },
  { "key": "Scarlett" },
  { "key": "Aria" },
  { "key": "Mia" },
  { "key": "Samantha" },
  { "key": "Natalie" },
  { "key": "Camila" },
  { "key": "Layla" },
  { "key": "Riley" },
  { "key": "Aubrey" },
  { "key": "Hazel" },
  { "key": "Luna" },
  { "key": "Victoria" },
  { "key": "Addison" },
  { "key": "Brooklyn" },
  { "key": "Hannah" },
  { "key": "Lillian" },
  { "key": "Nora" },
  { "key": "Ellie" },
  { "key": "Lucy" },
  { "key": "Savannah" },
  { "key": "Mila" },
  { "key": "Kinsley" },
  { "key": "Peyton" },
  { "key": "Bailey" },
  { "key": "Skylar" },
  { "key": "Bella" },
  { "key": "Stella" },
  { "key": "Eva" },
  { "key": "Madison" },
  { "key": "Clara" },
  { "key": "Julia" },
  { "key": "Sophie" },
  { "key": "Arianna" },
  { "key": "Autumn" },
  { "key": "Kylie" },
  { "key": "Isabella" },
  { "key": "Gianna" },
  { "key": "Serenity" },
  { "key": "Kaylee" },
  { "key": "Mackenzie" },
  { "key": "Jasmine" },
  { "key": "Elliana" },
  { "key": "Reagan" },
  { "key": "Iris" },
  { "key": "Delilah" },
  { "key": "Faith" },
  { "key": "Ayla" },
  { "key": "Sienna" },
  { "key": "Maddison" },
  { "key": "Samantha" },
  { "key": "Taylor" },
  { "key": "Brooke" },
  { "key": "Alexis" },
  { "key": "Maria" },
  { "key": "Gianna" },
  { "key": "Leah" },
  { "key": "Cora" },
  { "key": "Lydia" },
  { "key": "Ophelia" },
  { "key": "Amara" },
  { "key": "Elena" },
  { "key": "Evangeline" },
  { "key": "Adeline" },
  { "key": "Emery" },
  { "key": "Emilia" },
  { "key": "Katherine" },
  { "key": "Vivian" },
  { "key": "Rosalie" },
  { "key": "Brielle" },
  { "key": "Cecilia" },
  { "key": "Adele" },
  { "key": "Margo" },
  { "key": "Kate" },
  { "key": "Ruth" },
  { "key": "Maya" },
  { "key": "Jade" },
  { "key": "Piper" },
  { "key": "Paige" },
  { "key": "Megan" },
  { "key": "Jordan" },
  { "key": "Tessa" },
  { "key": "Kimberly" },
  { "key": "Angela" },
  { "key": "Aaliyah" },
  { "key": "Michaela" },
  { "key": "Sierra" },
  { "key": "Sabrina" },
  { "key": "Diana" },
  { "key": "Juliana" },
  { "key": "Lila" },
  { "key": "Alana" },
  { "key": "Cynthia" },
  { "key": "Misty" },
  { "key": "Elle" },
  { "key": "Fiona" },
  { "key": "Misty" },
  { "key": "Mabel" },
  { "key": "Mara" },
  { "key": "Sky" },
  { "key": "Sage" },
  { "key": "Wren" },
  { "key": "Briar" },
  { "key": "Rhea" },
  { "key": "Carmen" },
  { "key": "Raven" },
  { "key": "Cleo" },
  { "key": "Nina" },
  { "key": "Lola" },
  { "key": "Nova" },
  { "key": "Elsie" },
  { "key": "Maisie" },
  { "key": "Dahlia" },
  { "key": "Talia" },
  { "key": "Raina" },
  { "key": "Mina" },
  { "key": "Kenna" },
  { "key": "Thea" },
  { "key": "Sable" },
  { "key": "Freya" },
  { "key": "Lyra" }
];

var second = 
[
  "Alice",
  "Emma",
  "David",
  "Sam",
  "Oscar",
  "Eve",
  "Grace",
  "Mason",
  "Mia",
  "Nina",
  "Zach",
  "Leo",
  "Charlotte",
  "Hannah",
  "Jack",
  "Liam",
  "Tina",
  "Frank",
  "Ava",
  "Rita",
  "Camila",
  "Maddison",
  "Tessa",
  "Sophie",
  "Hannah",
  "Kathy",
  "Wendy",
  "Aaliyah",
  "Kylie",
  "Violet",
  "Natalie",
  "Ella",
  "Julia",
  "Faith",
  "Raven",
  "Juliana",
  "Misty",
  "Delilah",
  "Briar",
  "Rhea",
  "Sage",
  "Cleo",
  "Mara",
  "Wren",
  "Nova",
  "Maisie",
  "Sierra",
  "Thea",
  "Margo",
  "Freya",
  "Zach",
  "Kathy",
  "Lydia",
  "Maya",
  "Sable",
  "Cynthia",
  "Ivy",
  "Skylar",
  "Reagan",
  "Adeline",
  "Jade",
  "Piper",
  "Kinsley",
  "Autumn",
  "Isabella",
  "Luna",
  "Samantha",
  "Arianna",
  "Ayla",
  "Nora",
  "Cora",
  "Ella",
  "Lila",
  "Zoe",
  "Xander",
  "Victor",
  "Ivy",
  "Mila",
  "Hazel",
  "Ellie",
  "Violet",
  "Sierra",
  "Maisie",
  "Carmen",
  "Cleo",
  "Peyton",
  "Sam",
  "Dahlia",
  "Lola",
  "Ava",
  "Nina",
  "Sophie",
  "Ella",
  "Misty",
  "Alana",
  "Olivia",
  "Freya",
  "Lydia",
  "Ayla",
  "Layla",
  "Maddison",
  "Jade",
  "Zach",
  "Emma",
  "Rita",
  "Sable",
  "Wendy",
  "Thea",
  "Mabel",
  "Rhea",
  "Carmen",
  "Faith",
  "Alana"
]

Tests:

Lodash intersection
const result = _.intersectionWith(first, second, (obj, key) => obj.key === key); console.log('lodash', result);
Javascript includes
const keys = first.map(e => e.key); const result = keys.filter(a => second.includes(a)); console.log('includes', result);
Javascript indexOf
const keys = first.map(e => e.key); const result = keys.filter(a => second.indexOf(a) >= 0); console.log('indexOf', result);
Javascript Set intersection
const secondSet = new Set(second); const result = first.filter(item => secondSet.has(item.key)); console.log('set', result);

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	5008.1 Ops/sec
Javascript includes	7618.1 Ops/sec
Javascript indexOf	7593.3 Ops/sec
Javascript Set intersection	6733.3 Ops/sec

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

LLMs can make mistakes. Check important info.

## Benchmark Overview

The benchmark titled "Lodash vs Set Intersection vs includes vs indexOf (not ordered list)" is designed to compare the performance of several methods for finding intersections between two datasets: one characterized as a list of objects and the other as an array of strings. The goal is to evaluate how different approaches handle this intersection task and how fast each method performs.

## Methods Compared

1. **Lodash Intersection (`_.intersectionWith`)**:
   - **Implementation**: This method uses the Lodash library's `intersectionWith` function along with a custom comparator function that checks for equality between the `key` property of objects in the first array and the string elements in the second array.
   - **Pros**: 
     - The code is concise and uses a well-established library that abstracts away the complexity.
     - It can be easily extended for more complex intersection scenarios.
   - **Cons**: 
     - Introduces the overhead of including an external library, which can have an impact on performance.
     - May be slower due to additional functionalities and checks that Lodash performs under the hood.

2. **JavaScript `includes` Method**:
   - **Implementation**: It converts the list of objects to an array of strings (keys), then utilizes the native `Array.prototype.includes()` method to check for the presence of each key in the second array.
   - **Pros**: 
     - Simple and efficient for smaller datasets; native method implementation in JavaScript is optimized.
     - No external dependencies; everything is built into the language itself.
   - **Cons**:
     - As the size of data increases, the performance can degrade due to the linear time complexity of `includes` for each lookup.

3. **JavaScript `indexOf` Method**:
   - **Implementation**: Like the `includes` method, this approach first maps the `key` values then utilizes the `indexOf` method to check for the existence of each key in the second array.
   - **Pros**:
     - Also a native method, which allows for potentially better performance than a library-based approach in scenarios where the dataset is reasonably sized.
   - **Cons**:
     - Similar to `includes`, `indexOf` also has linear time complexity for each lookup. 
     - Tends to be less readable than `includes` for checking existence (as `indexOf` requires a non-negative check).

4. **JavaScript `Set` Intersection**:
   - **Implementation**: This method converts the second array into a `Set` and checks for the existence of keys from the first list of objects by using the `Set.prototype.has()` method.
   - **Pros**: 
     - The `Set` is designed for fast lookups; average time complexity for lookup operations is O(1).
     - More efficient retrieval as the lookup does not involve traversing the full array each time.
   - **Cons**:
     - Initial setup of the Set incurs additional overhead, especially for small datasets where the benefits may not justify the cost.
     - Slightly more complex to read and understand compared to other methods.

## Benchmark Results

The benchmark results reflect the measures of executions per second for each method tested. Here’s a summary from the results:

- **JavaScript `includes`**: Approximately **7618 executions/second**
- **JavaScript `indexOf`**: Approximately **7593 executions/second**
- **JavaScript `Set` intersection**: Approximately **6733 executions/second**
- **Lodash intersection**: Approximately **5008 executions/second**

These results indicate that while the `includes` and `indexOf` methods perform quite similarly and the fastest overall, the Lodash method shows the poorest performance, which could potentially be due to the overhead of using the library.

## Considerations and Alternatives

### Considerations:
- **Data Size**: The performance of each approach may vary significantly with different sizes of `first` and `second` arrays. Smaller datasets might not reveal significant differences.
- **Readability vs. Performance**: Developers often need to balance code readability and maintainability with performance. Libraries like Lodash offer readable and easily maintainable code but can introduce performance overhead in certain scenarios.
- **Extensibility**: If more complex intersection logic is needed in the future, the Lodash approach can be more beneficial.

### Alternatives:
- **Using a Map**: Storing values in a Map or an Object for constant-time lookup could achieve even better performance, especially for larger arrays.
- **Custom Implementations**: Depending on the particular needs of an application, a custom binary search or other algorithms could leverage sorted data for optimal performance.
- **Typed Arrays or Other Data Structures**: When dealing with large datasets, considering specialized data structures can lead to performance improvements.

In conclusion, the chosen approach largely depends on the specific use case, data characteristics, and project constraints regarding performance and maintainability. Each method has its strengths and weaknesses, and adopting a combination of methods could yield optimal results based on the given scenario.

Related benchmarks:

Lodash vs Set Intersection vs includes vs indexOf (not ordered list) (version: 6)

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

Created: 14 days ago by: Registered User

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