Benchmark: Lodash difference vs Filter

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 < 10000; i++) {
  arr1.push('' + i);
}

var arr2 = [];
for(let i = 490; i >= 0; i--) {
  arr2.push('' + i);
}

Tests:

Lodash : small base
const notInArr1 = _.difference(arr2, arr1)
Set & Filter: small base
const notInArr1 = arr2.filter(value => !arr1.includes(value));
Set & Filter: large base
const notInArr2 = arr1.filter(value => !arr2.includes(value));
Lodash: large base
const notInArr2 = _.difference(arr1, arr2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash : small base
Set & Filter: small base
Set & Filter: large base
Lodash: large base

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 dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided benchmark compares two approaches to find elements that are not in an array using Lodash and the native `filter()` method with `includes()`. We'll break down what's being tested, the pros and cons of each approach, and discuss other alternatives.

**What is being tested?**

Three individual test cases are compared:

1. **Lodash**: Using the `difference()` function from Lodash to find elements that are not in `arr2`.
2. **Native Filter with Includes**: Using the native `filter()` method with a callback function that checks if an element is not included in `arr1` using `includes()`.
3. **Set & Filter (Lodash)**: Using Lodash's `difference()` function to find elements that are not in `arr2`, but this time, first converting both arrays to sets.
4. **Set & Filter (Native Filter with Includes)**: Similar to the previous point, using native `filter()` method with a callback function that checks if an element is not included in `arr1` using `includes()`, and then converting both arrays to sets.

**Options compared**

The benchmark compares two main approaches:

* **Lodash**: Using Lodash's built-in functions for array manipulation.
* **Native Filter with Includes**: Using native JavaScript methods for filtering and checking inclusion.

Each approach has its pros and cons:

* **Lodash**:
	+ Pros:
		- Generally faster than native methods, especially for larger arrays.
		- Easier to read and maintain due to the abstraction provided by Lodash's functions.
	+ Cons:
		- Additional dependency on Lodash library, which may not be included in all environments.
		- May have slower startup times due to the loading of Lodash.
* **Native Filter with Includes**:
	+ Pros:
		- No additional dependencies or overhead.
		- Can be faster for smaller arrays or when performance is critical.
	+ Cons:
		- More verbose and harder to read, especially for complex filtering scenarios.
		- May be slower for larger arrays due to the use of `includes()` method.

**Library: Lodash**

Lodash is a popular JavaScript library that provides a set of high-level functions for working with arrays, objects, and more. The `difference()` function used in this benchmark is part of Lodash's utility functions, which makes it easier to perform array operations without having to write custom code.

**Special JS feature: None**

There are no special JavaScript features or syntax used in these benchmarks. They rely solely on standard JavaScript methods and Lodash functions.

**Other alternatives**

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

* **Native Set Operations**: You can use native set operations (e.g., `Set.prototype.filter()`, `Set.prototype.has()`) to achieve similar results without Lodash.
* **Tail-Binding**: Some modern JavaScript engines support tail-bounding, which can improve performance for certain array manipulation scenarios.
* **SIMD Instructions**: If you're targeting a specific platform or hardware architecture that supports SIMD instructions (e.g., SSE, AVX), you might be able to optimize your code for better performance.

Keep in mind that these alternatives may have different trade-offs in terms of readability, maintainability, and platform support.

Related benchmarks:

Lodash difference vs Filter (version: 0)

Comparing performance of: Lodash : small base vs Set & Filter: small base vs Set & Filter: large base vs Lodash: large base

Created: 3 years ago by: Guest

Jump to the latest result

Lodash : small base

Set & Filter: small base

Set & Filter: large base

Lodash: large base

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