Benchmark: native intersect vs lodash intersection small and large

HTML Preparation code:

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

Script Preparation code:

function intersect(...array) {
    var s = new Set();
    for(var a of array) {
        for(var item of a) {
            s.add(item)
        }
    }
    return [...s];
}
var a1 = [];
var a2 = [];
var a3 = [];
for (var i = 0; i < 10; i++) {
  a1.push(~~(Math.random() * 10))
  a2.push(~~(Math.random() * 10))
  a3.push(~~(Math.random() * 10))
}

var a4 = [];
var a5 = [];
var a6 = [];
for (var i = 0; i < 1000; i++) {
  a4.push(~~(Math.random() * 100))
  a5.push(~~(Math.random() * 100))
  a6.push(~~(Math.random() * 100))
}

Tests:

native small
intersect(a1, a2, a3);
lodash small
_.intersection(a1, a2, a3);
native big
intersect(a4, a5, a6);
lodash big
_.intersection(a4, a5, a6);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native small
lodash small
native big
lodash big

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

The provided JSON represents a benchmark test case created using MeasureThat.net, which compares the performance of native JavaScript intersection functions with those from the popular library, Lodash.

**Benchmark Definition**

The `intersect` function is a simple implementation of an intersection function in JavaScript. It takes an array of arrays as input and returns a new array containing only the elements that are present in all the input arrays. The function uses a `Set` data structure to efficiently keep track of unique elements.

In contrast, Lodash provides its own `_.intersection()` function, which achieves the same result but may use different internal algorithms or optimizations to improve performance.

**Options Compared**

The benchmark compares two options:

1. **Native Intersection Function**: This is the custom implementation provided in the `intersect` function.
2. **Lodash Intersection Function**: The official implementation from Lodash.

Both functions are designed to perform a basic intersection operation on arrays of integers, but they might differ in terms of performance, memory usage, or other factors that could impact the results.

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **Native Intersection Function**:
	* Pros: Simple implementation, easy to understand, potentially optimized for specific use cases.
	* Cons: Might not be as efficient as native code optimizations or library-specific optimizations, may have performance overhead due to browser interpretation.
2. **Lodash Intersection Function**:
	* Pros: Potential for better performance through optimized internal algorithms, well-maintained and tested by a large community.
	* Cons: External dependency on the Lodash library, might add complexity to the codebase.

**Library Usage**

In this benchmark, the `_.intersection()` function from Lodash is used. The library provides various utility functions for common tasks, including array manipulation, string processing, and more. In this case, it's used to implement a simple intersection function that can be easily reused in other parts of the codebase.

**Special JS Features or Syntax**

There are no special JavaScript features or syntax mentioned in the provided benchmark. However, if you're interested in exploring other optimization techniques, some modern browsers support features like:

* WebAssembly (WASM): enables compilation of code to a low-level binary format that can be executed by the browser.
* Just-In-Time (JIT) compilation: optimizes performance-critical code paths at runtime.

Keep in mind that these features require specific configuration and may not be supported on all browsers or platforms.

**Other Alternatives**

If you're interested in exploring alternative intersection functions or optimization techniques, here are a few options:

1. **Built-in Array Methods**: Modern JavaScript arrays provide methods like `filter()`, `reduce()`, and `some()` that can be used to achieve an intersection-like result.
2. **External Libraries**: Other libraries like Ramda or Lodash alternatives (e.g., Immer) might offer optimized intersection functions with their own trade-offs.
3. **Custom Optimizations**: Depending on the specific use case, you may be able to optimize the `intersect` function further by exploiting browser-specific features, caching intermediate results, or using specialized data structures.

Feel free to ask if you'd like more information on any of these alternatives!

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
native small	1154813.8 Ops/sec
lodash small	1230596.8 Ops/sec
native big	27565.6 Ops/sec
lodash big	17736.8 Ops/sec

Related benchmarks:

native intersect vs lodash intersection small and large (version: 0)

Comparing performance of: native small vs lodash small vs native big vs lodash big

Created: 3 years ago by: Guest

Jump to the latest result

native small

lodash small

native big

lodash big

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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