Benchmark: Intersection filter vs lodash intersection test unsorted array

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 = [7, 2, 4, 1, 9, 8, 6, 3, 5]
var arr2 = [3, 4, 1, 2];

Tests:

filter unsorted
const result = arr1.filter(el => arr2.includes(el))
lodash intersection unsort
const result = _.intersection(arr1, arr2)
filter sorted
const sortedArr1 = arr1.sort() const sortedArr2 = arr2.sort() const result = sortedArr1.filter(el => sortedArr2.includes(el))
lodash intersection sorted
const sortedArr1 = arr1.sort() const sortedArr2 = arr2.sort() const result = _.intersection(sortedArr1, sortedArr2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
filter unsorted
lodash intersection unsort
filter sorted
lodash intersection sorted

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 dive into the benchmark.

The provided JSON represents a set of test cases for measuring JavaScript performance, specifically focusing on two approaches: using the native `filter()` method and using the Lodash library to perform an intersection operation.

**Native Filter Method**

The first test case (`"filter unsorted"`): This test measures the performance of the native `filter()` method when applied to an unsorted array. The code snippet provided creates two arrays, `arr1` and `arr2`, and uses the `filter()` method to find elements that are common to both arrays.

**Lodash Intersection**

The second test case (`"lodash intersection unsort"`): This test measures the performance of using Lodash's `intersection()` function to perform an intersection operation on two arrays, also in an unsorted state. The code snippet provided includes a reference to the Lodash library, which is used for this purpose.

**Sorted Arrays**

The next two test cases (`"filter sorted"` and `"lodash intersection sorted"`): These tests compare the performance of both approaches when applied to sorted arrays. In these cases, the arrays are first sorted using the `sort()` method before applying the intersection operation or filtering.

**Options Compared**

Two options are compared:

1.  **Native Filter Method vs Lodash Intersection**: This comparison measures the performance difference between using the native JavaScript `filter()` method versus the Lodash library's `intersection()` function for performing intersection operations on arrays.
2.  **Unsorted vs Sorted Arrays**: These comparisons measure the performance impact of sorting the input arrays before applying the intersection operation or filtering.

**Pros and Cons**

*   **Native Filter Method**:
    *   Pros: No additional overhead due to using a separate library, potentially better cache locality since the same native function is being called.
    *   Cons: May be slower than Lodash's optimized implementation for certain use cases, especially when dealing with large arrays or complex filtering logic.
*   **Lodash Intersection**:
    *   Pros: Optimized implementation for performance and might provide better results for certain edge cases. However, it introduces an additional overhead due to the need to load a separate library.
    *   Cons: Slower than native JavaScript methods, as well as requiring extra memory to store the loaded library.

**Library (Lodash)**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks such as array manipulation, string processing, and more. The `intersection()` function in Lodash is specifically designed to find common elements between two arrays, providing an optimized solution for this particular use case.

**Special JS Feature/Syntax**

None are mentioned explicitly; the code snippets provided focus on using standard JavaScript features like `filter()`, `sort()`, and array operations.

**Other Alternatives**

For the intersection operation, other libraries or native methods could be used as alternatives to Lodash's `intersection()` function. Some options include:

*   **Native Array.prototype.filter()**: This method can also be used to find common elements between two arrays.
*   **Underscore.js functions**: Other functions within the Underscore library (e.g., `_without`, `_difference`) could potentially be used for intersection operations, although they might have slightly different performance characteristics or use cases.

**Benchmark Considerations**

The benchmark should consider factors like:

*   Array size and complexity
*   Sorting strategy (if applicable)
*   Filtering logic (if applicable)
*   Number of executions per second
*   Device platform and OS

By considering these factors, you can get a more accurate picture of the performance differences between native JavaScript methods and Lodash's optimized implementation for intersection operations.

Latest run results:

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

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

Browser/OS: Chrome 101 on Windows

View result in a separate tab

Test name	Executions per second
filter unsorted	1038506.2 Ops/sec
lodash intersection unsort	1153391.4 Ops/sec
filter sorted	1363332.8 Ops/sec
lodash intersection sorted	831177.8 Ops/sec

Related benchmarks:

Intersection filter vs lodash intersection test unsorted array (version: 0)

Comparing performance of: filter unsorted vs lodash intersection unsort vs filter sorted vs lodash intersection sorted

Created: 4 years ago by: Registered User

Jump to the latest result

filter unsorted

lodash intersection unsort

filter sorted

lodash intersection sorted

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