Benchmark: Compare lodash some vs contains vs native foreach + lodash isEqual

HTML Preparation code:

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

Script Preparation code:

var sample = [];
var testArray = [];

function generateDefinition(i) {
    return {
        id: i,
        children: [
          {
              id: i
          }
        ]
    };
}

for (let i = 10; i > 0; i--){
   sample.push(generateDefinition(i));
}

for (let i = 0; i < 100; i ++)
{
   testArray.push(generateDefinition(i));
}

function contains(list, testItem) {
  let result = false;
  list.forEach(listItem => {
    if(_.isEqual(listItem, testItem)) {
      result = true;
      return;
    }
  });
  return result;
}

Tests:

use foreach + lodash isEqual
for (var i = 0; i < sample.length; i++) { contains(testArray, sample[i]) }
use lodash some
for (var i = 0; i < sample.length; i++) { _.some(testArray, sample[i]); }
use lodash contains
for (var i = 0; i < sample.length; i++) { _.includes(testArray, sample[i]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
use foreach + lodash isEqual
use lodash some
use lodash contains

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 109 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
use foreach + lodash isEqual	1933.7 Ops/sec
use lodash some	68967.4 Ops/sec
use lodash contains	177468.7 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its test cases.

**Benchmark Overview**

The benchmark compares three approaches for checking membership in an array:

1. Using `for` loop with `forEach` and `isEqual` (native JavaScript)
2. Using Lodash's `some` function
3. Using Lodash's `includes` function

The benchmark is designed to measure the performance of these approaches on a sample dataset.

**Library: Lodash**

Lodash is a popular JavaScript library that provides a collection of functional programming helpers, including array utilities like `some`, `includes`, and `isEqual`. The `some` function returns `true` if at least one element in an array satisfies a given predicate, while the `includes` function checks for direct inclusion. The `isEqual` function is used to compare two values for deep equality.

**Individual Test Cases**

Let's examine each test case:

1. **"use foreach + lodash isEqual"**: This approach uses a traditional `for` loop with `forEach` to iterate over the array and then uses Lodash's `isEqual` function to check if an item is present in the array.
2. **"use lodash some"**: This approach uses Lodash's `some` function, which directly checks for membership in the array.
3. **"use lodash contains"**: This approach uses Lodash's `contains` function, but it's not a native JavaScript function (it's an alias for `some`). However, since there is no "contains" built-in function on arrays in JS, this test case uses "lodash.some".

**Pros and Cons of Each Approach**

1. **"use foreach + lodash isEqual"**: Pros:

* Can be used with existing code that doesn't require a new library.
* Allows for fine-grained control over the iteration process.

Cons:

* May be slower due to the overhead of using `forEach` in combination with Lodash's `isEqual`.
2. **"use lodash some"**: Pros:

* Faster than using `forEach` and `isEqual`, as it avoids unnecessary iterations.
* More concise code.

Cons:

* Requires importing an additional library (Lodash).
3. **"use lodash contains"**: Since this test case uses "lodash.some", which is not a native JavaScript function, it's essentially the same as the "use lodash some" approach.

**Other Considerations**

When deciding between these approaches, consider the following factors:

* Performance: If speed is critical, using `some` might be faster.
* Code readability and maintainability: Using `forEach` with `isEqual` can provide a clear understanding of the iteration process.
* Library dependencies: If you prefer not to use Lodash, you'll need to choose between using a native JavaScript approach or another library.

**Alternatives**

If you don't want to use Lodash, you can consider alternative libraries like:

* Ramda: A functional programming library that provides similar array utilities.
* Underscore.js: Another popular utility library that includes array functions.
* Vanilla JavaScript: You could implement the `some` and `includes` functions yourself using native JavaScript methods.

Keep in mind that implementing these functions from scratch might not be as efficient or readable as using a dedicated library like Lodash.

Related benchmarks:

Compare lodash some vs contains vs native foreach + lodash isEqual (version: 1)

Compare lodash some vs contains vs native foreach + lodash isEqual

Comparing performance of: use foreach + lodash isEqual vs use lodash some vs use lodash contains

Created: 3 years ago by: Registered User

Jump to the latest result

use foreach + lodash isEqual

use lodash some

use lodash contains

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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