Benchmark: lodash difference vs reduce

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var list_1 = ["1","2","3","4","5","6"]
var list_2 = ["1","2","3"]

Tests:

lodash
_.difference(list_1, list_2)
Reduce
var excludeMap = list_2.reduce((all, item) => ({ ...all, [item]: true }), {}); list_1.filter((item) => !excludeMap?.[item]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash
Reduce

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Overview**

The benchmark compares two approaches to find the difference between two arrays: using Lodash's `difference` function versus using a custom implementation with the `reduce` method.

**Lodash's `difference` function**

* Purpose: To return a new array containing elements that are in the first array (`list_1`) but not in the second array (`list_2`).
* Library: Lodash is a popular JavaScript utility library that provides various functions for tasks like data manipulation, string manipulation, and more.
* Pros:
	+ Well-tested and widely used, so it's likely to be efficient.
	+ Provides a simple and concise way to solve the problem.
* Cons:
	+ May not be optimized for performance in all cases.
	+ Relies on Lodash being included in the browser or project.

**Custom implementation with `reduce`**

* Purpose: To create an exclusion map by iterating through `list_2` and adding each item as a key to the map. Then, filter `list_1` using this exclusion map.
* Pros:
	+ Customizable for performance optimization (e.g., caching or memoization).
	+ No external dependencies required.
* Cons:
	+ Requires more code and understanding of the algorithm.
	+ May be slower than Lodash's implementation.

**Other considerations**

* Both approaches have a time complexity of O(n), where n is the length of the input arrays. However, the custom implementation may benefit from optimizations like caching or memoization to improve performance.
* The benchmark uses Chrome 106 on a Mac OS X 10.15.7 desktop as the test environment.

**Benchmark result**

The latest benchmark result shows that Lodash's `difference` function performs better than the custom implementation with `reduce`. This is likely due to the optimized nature of Lodash's implementation and its widespread use.

If you're interested in exploring alternatives, here are a few options:

* Use other libraries like `lodash-es` (a subset of Lodash for ES6 compatibility) or `difference` functions from other utility libraries.
* Implement your own difference function using various algorithms (e.g., iterative, recursive).
* Consider using a more modern JavaScript approach, like using `Set` data structures to find differences.

Keep in mind that performance optimization may require additional testing and experimentation.

Latest run results:

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

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

Browser/OS: Chrome 106 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
lodash	3253977.2 Ops/sec
Reduce	2922562.2 Ops/sec

Related benchmarks:

lodash difference vs reduce (version: 0)

lodash difference vs reduce

Comparing performance of: lodash vs Reduce

Created: 2 years ago by: Guest

Jump to the latest result

lodash

Reduce

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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