Benchmark: _.intersection vs function

Tests:

function intersect
var a = { x: undefined, y: 1, z: 2, a: 10, b: 20, e: 30}; var b = { x: 0, y: 1, z: 2, a: 10, c: 20, d: 30}; function intersect(o1, o2) { const [k1, k2] = [Object.keys(o1), Object.keys(o2)]; const [first, next] = k1.length > k2.length ? [k2, o1] : [k1, o2]; return first.filter(k => k in next); } console.log(intersect(a, b))
_.intersection
var a = { x: undefined, y: 1, z: 2, a: 10, b: 20, e: 30}; var b = { x: 0, y: 1, z: 2, a: 10, c: 20, d: 30}; console.log(_.intersection(_.keys(a), _.keys(b)))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
function intersect
_.intersection

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'll provide an explanation of the provided benchmark.

**Overview**

The provided benchmark compares two approaches to finding the intersection of keys in two JavaScript objects: using a custom function (`intersect`) and using the `_.intersection` function from the Lodash library.

**Custom Function: `intersect`**

The custom `intersect` function takes two objects as input, `o1` and `o2`, and returns an array of keys that are present in both objects. Here's a breakdown of what happens:

1. It extracts the keys of each object using `Object.keys`.
2. It determines which object has more keys (using `k1.length > k2.length`) and assigns it to the variable `first`. The other object is assigned to `next`.
3. It uses `filter` to iterate over the keys in the first object and checks if each key is present in the second object (`next`). If a key is found, its index is added to the result array.

**Pros and Cons**

The custom function has some advantages:

* **Control**: By writing your own implementation, you have full control over how the intersection is calculated.
* **Flexibility**: You can modify the implementation to suit specific needs.

However, it also has some drawbacks:

* **Code duplication**: Writing a separate `intersect` function means duplicating code that could be reused elsewhere.
* **Error-prone**: With a custom implementation, there's a higher chance of introducing bugs or inconsistencies.

**Lodash `_intersection`**

The `_.intersection` function from Lodash is a wrapper around the native `Array.prototype.filter()` method. It takes two arrays as input and returns an array containing only the elements that are present in both arrays.

Pros:

* **Convenience**: The `_.intersection` function provides a simple and convenient way to calculate the intersection of keys.
* **Standardized behavior**: By using a standardized library, you can rely on consistent behavior across different implementations.

Cons:

* **External dependency**: Using Lodash requires including an external library, which may add unnecessary overhead.
* **Less control**: With `_.intersection`, you have less control over the underlying implementation and may not be able to customize it to suit specific needs.

**Other Considerations**

* **Performance**: In general, custom implementations can be optimized for performance, whereas Lodash functions are built on top of native JavaScript methods and may not be as efficient.
* **Readability**: Using a standardized library like Lodash can make code more readable by hiding implementation details.

**Alternatives**

If you're looking for alternatives to the `_.intersection` function, consider using other libraries or implementing your own intersection calculation. Some popular options include:

* Other Lodash functions (e.g., `_difference`, `_union`)
* Native JavaScript methods (e.g., `Array.prototype.filter()`)
* Custom implementations with optimized algorithms
* Third-party libraries like `lodash-es` or `fast-leviathan`

Keep in mind that the choice of implementation depends on your specific use case, performance requirements, and personal preferences.

Related benchmarks:

_.intersection vs function (version: 0)

Comparing performance of: function intersect vs _.intersection

Created: 4 years ago by: Guest

Jump to the latest result

function intersect

_.intersection

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