Benchmark: loadash vs set - MeasureThat.net

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 = [{batchId: 2, userId: 234},{batchId: 2, userId: 232},{batchId: 2, userId: 224},{batchId: 2, userId: 222}];
var second = [{batchId: 3, userId: 234},{batchId: 3, userId: 232},{batchId: 3, userId: 224},{batchId: 3, userId: 222}];

Tests:

intersection
_.intersection(first, second)
set
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
intersection
set

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 3 days ago):

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The provided benchmark compares two approaches to find the intersection of two arrays: `lodash` (a popular utility library) and the native `Set` data structure in JavaScript.

**Benchmark Definitions**

There are two benchmark definitions:

1. **`_.intersection(first, second)`**: This uses the Lodash `intersection` function to find the common elements between the two input arrays (`first` and `second`). The Lodash library is used here to provide a convenient and efficient way to perform set operations.
2. **`const firstSet = new Set(first); const secondSet = new Set(second); ...`**: This uses native JavaScript `Set` data structures to find the intersection of the two arrays. It creates separate sets from each array, filters one set using the other, and then creates a new set from that filtered result.

**Approaches Compared**

We have two approaches being compared:

1. **Lodash (`_.intersection(first, second)`)**: This approach uses Lodash's `intersection` function to find the intersection of the two arrays.
2. **Native `Set` data structure (`const firstSet = new Set(first); const secondSet = new Set(second); ...`)**: This approach uses native JavaScript sets to perform set operations.

**Pros and Cons**

Here are some pros and cons of each approach:

1. **Lodash (`_.intersection(first, second)`)**:
	* Pros:
		+ Convenient and efficient way to perform set operations
		+ Easy to use and understand (for those familiar with Lodash)
	* Cons:
		+ Adds overhead due to the external library dependency
		+ Might not be as optimized or performance-critical as native code
2. **Native `Set` data structure (`const firstSet = new Set(first); const secondSet = new Set(second); ...`)**:
	* Pros:
		+ No additional dependencies (just built-in JavaScript)
		+ Can be more performance-critical due to native optimization
	* Cons:
		+ Requires understanding of native set operations and implementation details
		+ Might be less convenient or easier to use for some developers

**Library: Lodash**

Lodash is a popular utility library for JavaScript that provides various functions for tasks like array manipulation, string manipulation, and more. The `intersection` function used in the benchmark is part of Lodash's set operations.

**Special JS Feature/Syntax: None**

There are no special JavaScript features or syntax being tested or utilized in this benchmark.

**Other Alternatives**

If you need to find the intersection of two arrays, you might also consider using other libraries like `underscore` (another popular utility library) or `array-queue-intersection` (a lightweight library for finding array intersections). Alternatively, you could use a simple and efficient algorithm like `filter()` + `includes()`, but this would likely be less optimized than the native set approach.

In conclusion, the benchmark on MeasureThat.net provides a good example of how to compare two approaches to find the intersection of two arrays in JavaScript: using Lodash's `intersection` function versus native sets.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.88 Safari/537.36

Browser/OS: Chrome 100 on Linux

View result in a separate tab

Test name	Executions per second
intersection	1104962.0 Ops/sec
set	700364.3 Ops/sec

Related benchmarks:

loadash vs set (version: 0)

Comparing performance of: intersection vs set

Created: 2 years ago by: Guest

Jump to the latest result

intersection

set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 3 days ago):