Benchmark: loadash vs set eg2

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 = [];
var second = [];
for(var i=0; i<10; i++) {
  first.push({batchId: Math.floor(Math.random() * 100)    , userId: Math.floor(Math.random() * 100)})
  second.push({batchId: Math.floor(Math.random() * 100)    , userId: Math.floor(Math.random() * 100)})
}

Tests:

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

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 provided JSON and benchmarking code to understand what is being tested.

**Benchmark Definition:**
The benchmark is comparing two approaches for finding the intersection of two arrays:

1. Using `lodash` library's `intersectionWith()` method, which takes an additional callback function that checks if elements are equal.
2. Manually creating a set from one array and then filtering it to find common elements with another set.

**Options Compared:**

* **Lodash Approach:** The benchmark tests how the `intersectionWith()` method performs on arrays of varying sizes (10-100 elements).
* **Manual Set Approach:** The benchmark measures how performance changes when using an external library (`lodash`) versus a custom implementation using sets and filtering.
* **Library Used:** Lodash, a popular JavaScript utility library.

**Pros and Cons:**

* **Lodash Approach:**
	+ Pros:
		- Easy to implement and maintain.
		- Provides a convenient way to perform set operations.
	+ Cons:
		- Requires including an external library.
		- May incur overhead due to the library's functionality.
* **Manual Set Approach:**
	+ Pros:
		- No external dependencies (just built-in JavaScript sets).
		- Efficient for small to medium-sized arrays.
	+ Cons:
		- More complex implementation and maintenance.

**Other Considerations:**

* The benchmarking code creates two arrays, `first` and `second`, with random elements. This simulates a scenario where performance is affected by data distribution (e.g., sparse vs dense data).
* Using an external library like Lodash can provide additional features beyond simple set operations (e.g., sorting, mapping).

**Special JS Feature/ Syntax:**

There are no specific JavaScript features or syntax mentioned in the benchmarking code.

**Test Case Analysis:**

The first test case, "intersection with," measures how performance changes when using the `lodash` library's `intersectionWith()` method. The second test case, "set," evaluates the efficiency of manually creating a set from one array and then filtering it to find common elements with another set.

**Alternatives:**

Other approaches for finding intersections between arrays include:

1. Using `Array.prototype.filter()`: This method creates a new array with all elements that pass the provided test.
2. Utilizing `Set.prototype.size` and `Set.prototype.has()`: These methods can be used to count the common elements without explicitly filtering or creating a set.

These alternatives may offer better performance for specific use cases, but they might require more complex implementations than the manual set approach or leveraging an external library like Lodash.

Related benchmarks:

loadash vs set eg2 (version: 0)

test

Comparing performance of: intersection with vs set

Created: 4 years ago by: Guest

Jump to the latest result

intersection with

set

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