Benchmark: native intersect vs lodash intersection 4

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

Tests:

native
intersect(a1, a2, a3);
lodash
_.intersection(a1, a2, a3);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
native
lodash

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.

I'd be happy to explain the benchmark and its results.

**What is being tested?**

The provided JSON represents a microbenchmarking test case on MeasureThat.net, where two different approaches are compared: using the native JavaScript `Set` object to implement an intersection function (`intersect`) versus using the popular JavaScript library Lodash's `intersection` function.

**Options compared:**

1. **Native Intersection**: The first option uses a custom implementation of the intersection function in JavaScript. It creates a new `Set` object and iterates over each array, adding elements to the set as it goes. Finally, it returns an array of the unique elements present in all arrays.
2. **Lodash Intersection**: The second option uses Lodash's built-in `intersection` function, which is designed to work with multiple arrays.

**Pros and Cons:**

1. **Native Intersection**:
	* Pros:
		+ Typically faster and more efficient since it avoids the overhead of a library call.
		+ Can be optimized for specific use cases or performance-critical code paths.
	* Cons:
		+ Requires manual implementation of the intersection logic, which can be error-prone and less readable.
		+ May not work as well with large arrays or complex data structures.
2. **Lodash Intersection**:
	* Pros:
		+ Highly optimized and tested, reducing the likelihood of performance issues.
		+ Supports multiple arrays and various sorting orders.
	* Cons:
		+ Introduces additional overhead due to the library call and function invocation.
		+ May not be suitable for very large or performance-critical applications.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks like data manipulation, string manipulation, and more. The `intersection` function in particular is designed to work with multiple arrays, returning an array of elements present in all input arrays.

**Special JS feature or syntax: None**

There are no special features or syntax used in this benchmark that would require additional explanation.

**Other alternatives:**

For creating an intersection function, other libraries like Ramda or Liskelme might be considered. However, these options might not offer the same level of optimization and performance as the native JavaScript implementation or Lodash's `intersection` function.

In summary, the benchmark compares two approaches to implementing an intersection function in JavaScript: a custom native implementation versus using Lodash's `intersection` function. The choice between these options depends on factors like performance requirements, code readability, and maintenance complexity.

Related benchmarks:

native intersect vs lodash intersection 4 (version: 0)

Comparing performance of: native vs lodash

Created: 4 years ago by: Guest

Jump to the latest result

native

lodash

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