Benchmark: Lodash: difference vs intersection1

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/lodash/4.16.0/lodash.min.js"></script>

Script Preparation code:

 var arrFull = new Array(20000);
    var arrOne = new Array(20000);
    var c = [];
    for(var x = 0; x < 20001; x++) {
        arrFull.push(x);
        arrOne.push(x);
    }

Tests:

Difference - Full
_.difference(arrFull, arrFull)
Intersection - Full
_.intersection(arrFull, arrFull)
Difference - Partial
_.difference(arrFull, arrOne)
Intersection - Partial
_.intersection(arrOne, arrFull)
filter1
c = arrOne.filter(x => arrFull.includes(x));
filter2
c = arrOne.filter(value => -1 !== arrFull.indexOf(value))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Difference - Full
Intersection - Full
Difference - Partial
Intersection - Partial
filter1
filter2

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**What is tested?**

The provided JSON represents a benchmark test for JavaScript functions that perform set operations: difference and intersection. The test creates two arrays, `arrFull` and `arrOne`, with 20,000 elements each, and then uses the Lodash library to compute the differences and intersections of these arrays.

**Options compared**

There are four different approaches tested:

1. **_.difference(arrFull, arrFull)**: This function computes the difference between the two full arrays.
2. **_.intersection(arrFull, arrFull)**: This function computes the intersection between the two full arrays.
3. **_.difference(arrFull, arrOne)**: This function computes the difference between the full array and the partial array.
4. **_.intersection(arrOne, arrFull)**: This function computes the intersection between the partial array and the full array.

**Pros and Cons of each approach**

1. **_.difference(arrFull, arrFull)**:
	* Pros: Simple and efficient for computing differences with identical arrays.
	* Cons: Unnecessary computations when comparing identical arrays.
2. **_.intersection(arrFull, arrFull)**:
	* Pros: Fast and efficient for computing intersections with identical arrays.
	* Cons: Still unnecessary computations when comparing identical arrays.
3. **_.difference(arrFull, arrOne)**:
	* Pros: Can be useful when comparing a full array with a partial one to identify missing elements.
	* Cons: May not be as efficient as the first two approaches.
4. **_.intersection(arrOne, arrFull)**:
	* Pros: Can help find common elements between a partial and full array.
	* Cons: May not be as efficient as the first three approaches.

**Lodash library**

Lodash is a popular JavaScript utility library that provides various functions for tasks such as data manipulation, functional programming, and more. The `_.difference` and `_.intersection` functions are part of Lodash's "Set Operations" module, which allows users to perform set operations on arrays and objects.

**Special JS features or syntax**

None mentioned in the provided JSON.

**Other alternatives**

For set operations, other libraries or built-in methods can be used:

1. **Array.prototype.filter()**: This method is available in modern browsers and Node.js environments. It can be used to compute differences and intersections by filtering out elements that are not present in the other array.
2. **Set data structure**: JavaScript's built-in `Set` object provides a fast way to perform set operations.

In conclusion, the benchmark test evaluates the performance of Lodash's set operations functions against alternative approaches using native JavaScript methods or the `Set` data structure. The results provide insights into which approach is most efficient for specific use cases.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36

Browser/OS: Chrome 79 on Windows

View result in a separate tab

Test name	Executions per second
Difference - Full	254.3 Ops/sec
Intersection - Full	227.0 Ops/sec
Difference - Partial	253.9 Ops/sec
Intersection - Partial	227.7 Ops/sec
filter1	2.1 Ops/sec
filter2	2.1 Ops/sec

Related benchmarks:

Lodash: difference vs intersection1 (version: 0)

Comparing performance of: Difference - Full vs Intersection - Full vs Difference - Partial vs Intersection - Partial vs filter1 vs filter2

Created: 4 years ago by: Registered User

Jump to the latest result

Difference - Full

Intersection - Full

Difference - Partial

Intersection - Partial

filter1

filter2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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