Benchmark: Array vs. Set Intersection

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:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Javascript Set intersection
Lodash intersection

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.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested, compared, and the pros and cons of each approach.

**Benchmark Overview**

The benchmark compares two approaches to perform an intersection between two arrays/set: using JavaScript's built-in `Set` data structure and using Lodash's filtering functionality.

**Options Compared**

1. **JavaScript Set Intersection**: This option uses the `Set` data structure to store unique values from the first array, filters out elements that are not present in the second set, and returns a new set with the intersecting elements.
2. **Lodash Intersection**: This option uses Lodash's filtering functionality (`filter`) to create a new array with elements that are common to both arrays.

**Pros and Cons of Each Approach**

1. **JavaScript Set Intersection**:
	* Pros:
		+ Faster execution time, as `Set` operations are optimized for performance.
		+ More memory-efficient, as only unique values are stored in the set.
		+ Can handle large datasets efficiently.
	* Cons:
		+ Requires JavaScript version support (at least ES6) and the ability to create a `Set` object.
		+ May not work in older browsers that don't support `Set`.
2. **Lodash Intersection**:
	* Pros:
		+ Easier to understand and implement, as it's built on top of a familiar library (Lodash).
		+ Can be used with any JavaScript version, including older ones.
	* Cons:
		+ Slower execution time compared to the `Set` approach.
		+ May consume more memory due to the creation of an intermediate array.

**Library: Lodash**

Lodash is a popular JavaScript library that provides various utility functions for tasks such as data manipulation, string manipulation, and more. The `filter` function used in the Lodash intersection benchmark is one of its most commonly used utilities. It takes two arguments: a callback function and an array to filter.

**Test Case Considerations**

The test case uses a special JS feature or syntax (the use of `const` and template literals) that may not be familiar to all software engineers, especially those who are new to JavaScript.

**Other Alternatives**

If you wanted to implement the intersection using another approach, some alternatives could be:

* Using `indexOf()` method on an array to check for presence of elements.
* Implementing a custom loop-based solution using a hash table or a similar data structure.

However, these approaches would likely be slower and less efficient than the `Set` or Lodash methods.

Related benchmarks:

Array vs. Set Intersection (version: 0)

Comparing performance of: Javascript Set intersection vs Lodash intersection

Created: 3 years ago by: Guest

Jump to the latest result

Javascript Set intersection

Lodash intersection

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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