Benchmark: Lodash: difference vs intersection vs includes

HTML Preparation code:

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

Script Preparation code:

var arrFull = ['past','present','future']
var arrOne = ['past']
Array.prototype.excludes = function(item) {
	return !this.includes(item)
}

Tests:

Difference - Full
_.difference(arrFull, arrFull)
Intersection - Full
_.intersection(arrFull, arrFull)
Difference - Partial
_.difference(arrFull, arrOne)
Intersection - Partial
_.intersection(arrOne, arrFull)
Difference - includes
arrFull.filter(item => !arrFull.includes(item))
Intersection - includes
arrFull.filter(item => arrFull.includes(item))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Difference - Full
Intersection - Full
Difference - Partial
Intersection - Partial
Difference - includes
Intersection - includes

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Difference - Full	13838906.0 Ops/sec
Intersection - Full	9519953.0 Ops/sec
Difference - Partial	13336374.0 Ops/sec
Intersection - Partial	13270949.0 Ops/sec
Difference - includes	46164232.0 Ops/sec
Intersection - includes	33750364.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Let's dive into explaining the provided benchmark.

**Benchmark Overview**

The benchmark measures the performance of different algorithms for finding differences and intersections between two arrays, as well as filtering an array using `includes` method. The test cases cover various scenarios, including:

* Full vs partial arrays
* Including all elements (full) vs excluding some elements (partial)
* Using Lodash's `difference`, `intersection`, and filtering functions

**Options Compared**

The benchmark compares the performance of three options for each test case:

1. **Lodash's `difference` function**: This function returns a new array containing elements that are in `arrFull` but not in `arrOne`.
2. **Lodash's `intersection` function**: This function returns an array containing elements that are common to both `arrFull` and `arrOne`.
3. **Manual filtering using `includes` method**: This approach uses the `includes` method to filter out elements from `arrFull`.

**Pros and Cons of Each Approach**

1. **Lodash's `difference` function**:
	* Pros: Efficient, concise, and easy to read.
	* Cons: Requires Lodash library, which may not be included in all environments (e.g., Node.js).
2. **Lodash's `intersection` function**:
	* Pros: Similar to `difference`, but uses a different algorithm for finding common elements.
	* Cons: Also requires Lodash library and may not work in all environments.
3. **Manual filtering using `includes` method**:
	* Pros: No dependencies, can be more efficient for small arrays.
	* Cons: May be less readable, as it involves multiple iterations.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides various functions for tasks such as array manipulation, function currying, and string manipulation. The `difference` and `intersection` functions in this benchmark are part of the Lodash library.

**Special JS Feature/ Syntax**

This benchmark uses a special syntax for defining a custom `Array.prototype.excludes` method, which is not a standard JavaScript feature. This allows the test to create a custom array method that can be used to filter out elements from an array.

**Alternative Approaches**

Other alternatives for finding differences and intersections between arrays include:

* Using `Set` data structure: Convert both arrays to sets, find their difference or intersection using set operations.
* Using `forEach` loop: Iterate through both arrays and compare each element manually.
* Using a custom implementation with bitwise operations: Compare elements using bitwise operations (e.g., `arrFull.includes(item)`).

Note that these alternatives may not be as efficient or concise as the Lodash functions, but they can be useful for educational purposes or when working in environments without Lodash.

Related benchmarks:

Lodash: difference vs intersection vs includes (version: 0)

Comparing performance of: Difference - Full vs Intersection - Full vs Difference - Partial vs Intersection - Partial vs Difference - includes vs Intersection - includes

Created: 5 years ago by: Guest

Jump to the latest result

Difference - Full

Intersection - Full

Difference - Partial

Intersection - Partial

Difference - includes

Intersection - includes

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):