Benchmark: EGO Intersection lodash vs underscore vs manual

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.4/lodash.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/underscore@1.13.1/underscore-min.js"></script>

AخA
 
<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.4/lodash.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/underscore@1.13.1/underscore-min.js"></script>

Script Preparation code:

var underscore = _.noConflict();

var objectArrays = [
  ['bedroom', 'kitchen', 'bathroom', 'living room', 'indoors', 'outdoors', 'city', 'urban', 'villa', 'hotel'],
  ['bed', 'kitchen island', 'bath', 'room', 'city'],
  ['bed', 'bathroom', 'bath', 'room', 'city']
];

​x
 
var underscore = _.noConflict();​var objectArrays = [  ['bedroom', 'kitchen', 'bathroom', 'living room', 'indoors', 'outdoors', 'city', 'urban', 'villa', 'hotel'],  ['bed', 'kitchen island', 'bath', 'room', 'city'],  ['bed', 'bathroom', 'bath', 'room', 'city']];​

Tests:

manual lodash

let shared = [];

objectArrays.forEach((array, i) => {
  if (i === 0) {
    shared.push(...array);
  }
  else {
    _.intersection(shared, array);
  }
});

 
let shared = [];​objectArrays.forEach((array, i) => {  if (i === 0) {    shared.push(...array);  }  else {    _.intersection(shared, array);  }});

manual underscore

let shared = [];

objectArrays.forEach((array, i) => {
  if (i === 0) {
    shared.push(...array);
  }
  else {
    underscore.intersection(shared, array);
  }
});

 
let shared = [];​objectArrays.forEach((array, i) => {  if (i === 0) {    shared.push(...array);  }  else {    underscore.intersection(shared, array);  }});

Lodash
const arrayLodash = _.intersection(...objectArrays);
const arrayLodash = _.intersection(...objectArrays);
Underscore
const arrayUnderscore = underscore.intersection(...objectArrays);
const arrayUnderscore = underscore.intersection(...objectArrays);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
manual lodash
manual underscore
Lodash
Underscore

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36

Browser/OS: Chrome 100 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
manual lodash	447775.0 Ops/sec
manual underscore	624814.6 Ops/sec
Lodash	866699.6 Ops/sec
Underscore	1333295.5 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

Let's dive into the world of JavaScript microbenchmarks and explore what's being tested on this provided JSON.

Benchmark Overview

The benchmark compares the performance of three approaches to find the intersection of two arrays:

Manual: Implementing the intersection operation from scratch without using any libraries.
Lodash: Using the popular lodash library, which provides a robust set of utility functions for JavaScript development.
Underscore: Using the underscore library, which is similar to lodash but has some differences in its API.

Options Compared

The benchmark compares the performance of each approach on two identical sets of input arrays:

objectArrays: An array of two arrays, each containing a mix of strings and numbers.

The comparison is done using the same test case with different implementations: one for manual implementation, one for Lodash, one for Underscore, and another for manual implementation again (with a slight variation).

Pros and Cons

Manual:
- Pros: Can be optimized for specific use cases, has no external dependencies.
- Cons: Requires more code to implement, may have performance issues if not implemented correctly.
Lodash:
- Pros: Robust library with extensive testing, easy to use and integrate.
- Cons: Adds an external dependency, may have a higher overhead due to the extra abstraction layer.
Underscore:
- Pros: Similar to Lodash but with some differences in its API, still a popular choice.
- Cons: Also adds an external dependency, similar to Lodash.

Library Descriptions

Lodash: A widely used JavaScript library that provides a comprehensive set of utility functions for tasks like array manipulation, object transformation, and more. It's known for its robust testing and extensive documentation.
Underscore: Another popular JavaScript library that provides a smaller set of functional programming helpers than Lodash. While similar to Lodash, Underscore has some differences in its API and is often preferred by developers who want a lighter weight alternative.

Special JS Features or Syntax

There are no special JavaScript features or syntax used in this benchmark. The code only uses standard JavaScript features like arrays, loops, and function calls.

Other Alternatives

If you're interested in exploring other approaches to find the intersection of two arrays, here are some alternatives:

Using Set objects: You can convert both arrays to sets and then use the intersection method to find the common elements.
Implementing a custom algorithm: There are several algorithms available that can be used to find the intersection of two arrays, such as the Cartesian product or the Squeeze algorithm.

I hope this explanation helps you understand what's being tested in this benchmark!

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks and explore what's being tested on this provided JSON.

**Benchmark Overview**

The benchmark compares the performance of three approaches to find the intersection of two arrays:

1. **Manual**: Implementing the `intersection` operation from scratch without using any libraries.
2. **Lodash**: Using the popular `lodash` library, which provides a robust set of utility functions for JavaScript development.
3. **Underscore**: Using the `underscore` library, which is similar to `lodash` but has some differences in its API.

**Options Compared**

The benchmark compares the performance of each approach on two identical sets of input arrays:

* `objectArrays`: An array of two arrays, each containing a mix of strings and numbers.

**Pros and Cons**

* **Manual**:
	+ Pros: Can be optimized for specific use cases, has no external dependencies.
	+ Cons: Requires more code to implement, may have performance issues if not implemented correctly.
* **Lodash**:
	+ Pros: Robust library with extensive testing, easy to use and integrate.
	+ Cons: Adds an external dependency, may have a higher overhead due to the extra abstraction layer.
* **Underscore**:
	+ Pros: Similar to Lodash but with some differences in its API, still a popular choice.
	+ Cons: Also adds an external dependency, similar to Lodash.

**Library Descriptions**

* **Lodash**: A widely used JavaScript library that provides a comprehensive set of utility functions for tasks like array manipulation, object transformation, and more. It's known for its robust testing and extensive documentation.
* **Underscore**: Another popular JavaScript library that provides a smaller set of functional programming helpers than Lodash. While similar to Lodash, Underscore has some differences in its API and is often preferred by developers who want a lighter weight alternative.

**Special JS Features or Syntax**

There are no special JavaScript features or syntax used in this benchmark. The code only uses standard JavaScript features like arrays, loops, and function calls.

**Other Alternatives**

If you're interested in exploring other approaches to find the intersection of two arrays, here are some alternatives:

* Using `Set` objects: You can convert both arrays to sets and then use the `intersection` method to find the common elements.
* Implementing a custom algorithm: There are several algorithms available that can be used to find the intersection of two arrays, such as the **Cartesian product** or the **Squeeze** algorithm.

I hope this explanation helps you understand what's being tested in this benchmark!

Related benchmarks:

EGO Intersection lodash vs underscore vs manual (version: 0)

Comparing performance of: manual lodash vs manual underscore vs Lodash vs Underscore

Created: 3 years ago by: Registered User

Jump to the latest result