Benchmark: Lodash difference vs filtering via set membership

HTML Preparation code:

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

Script Preparation code:

var arr1 = [];
for(let i = 0; i < 100000; i++) {
  arr1.push(i.toString());
}

var arr2 = [];
for(let i = 9999; i >= 0; i--) {
  arr2.push(i.toString());
}

Tests:

Lodash
const notInArr2 = _.difference(arr1, arr2)
Set & Filter
const arr2Set = new Set(arr2); const notInArr2 = arr1.filter(value => !arr2Set.has(value));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash
Set & Filter

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 129 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash	243.8 Ops/sec
Set & Filter	280.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what is tested, compared, and some pros and cons of different approaches.

**Benchmark Context**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The benchmark in question compares two approaches for finding elements not present in an array `arr2` within another array `arr1`. One approach uses the Lodash library, while the other uses a set-based approach.

**Script Preparation Code**

The script preparation code generates two arrays:

* `arr1`: An array of 100,000 string elements created by pushing incrementing integers (from 0 to 99999) as strings.
* `arr2`: An array of 10,000 decrementing integer elements (from 9999 to 0), also as strings.

**Html Preparation Code**

The HTML preparation code includes a reference to the Lodash JavaScript library version 4.17.5.

**Benchmark Definition JSON**

The benchmark definition consists of two test cases:

1. **Lodash**: Uses the `_.difference` function from Lodash to find elements not present in `arr2`.
2. **Set & Filter**: Creates a Set from `arr2`, and then uses the `filter` method with a callback function to exclude elements that are present in the set.

**Comparison**

The comparison between these two approaches is aimed at measuring their performance. The test cases aim to determine which approach is faster, more efficient, or has better performance characteristics under various conditions.

**Pros and Cons of Different Approaches**

1. **Lodash (`_.difference`)**:
	* Pros: Easy to use, well-tested library with a large user base.
	* Cons: May have higher overhead due to the need for additional function calls and object creation.
2. **Set & Filter**:
	* Pros: Can be more efficient if the set is already sorted or has a specific property, reducing the number of iterations needed to find matching elements.
	* Cons: Requires manual Set creation, filtering logic, and potentially more complex code.

**Library Used - Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for data manipulation, array operations, string manipulation, and more. The `_.difference` function is part of this library and returns an array containing all elements present in the first argument but not in the subsequent arguments.

**Special JS Feature or Syntax - Set**

The use of Sets in this benchmark takes advantage of JavaScript's built-in Set data structure, which provides efficient membership testing and iteration. This allows for faster lookup and exclusion of elements from `arr1` when comparing with `arr2`.

**Alternatives**

Other approaches could be explored, such as:

* Using a custom implementation without relying on the Lodash library.
* Employing more advanced data structures like Trie or prefix trees for efficient string matching.
* Utilizing the `Array.prototype.forEach` and conditional statements to iterate through `arr1` and compare elements with `arr2`.
* Leveraging specialized libraries like FastJSON, JSON.NET, or Apache Commons Lang for optimized JSON processing.

Keep in mind that the performance of these alternative approaches might vary depending on specific requirements, system configurations, and the size of input datasets.

Related benchmarks:

Lodash difference vs filtering via set membership (version: 0)

Comparing performance of: Lodash vs Set & Filter

Created: 2 years ago by: Guest

Jump to the latest result

Lodash

Set & Filter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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