Benchmark: Native filter().length vs lodash sumBy vs lodash filter().size(), for large array

Native filter().length vs lodash sumBy vs lodash filter().size(), for large array (version: 3) Benchmark.js

As of 3/22/2022, the differences in the performance of the last three test cases have very different performances in Firefox and very similar performances in Chrome. For small arrays, see https://www.measurethat.net/Benchmarks/Show/17858/7/native-filterlength-vs-lodash-sumby-vs-lodash-filtersiz .

Comparing performance of: `Filter length vs lodash sumBy vs lodash filter chaining vs manualMethod1 vs manualMethod2 (with lambda function test) vs manualMethod3 (for-each loop, with lambda function test)`

Created: 4 years ago by: Registered User

Go to the latest result

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/lodash/4.17.21/lodash.min.js"></script>

Script Preparation code:

const arraySize = 500000;
window.array = _.range(arraySize).map(() => Math.random());

function manualMethod1(array) {
  let x = 0;
  let len = array.length;
  for (let i = 0; i < len; i++) {
    if (array[i] > .5) {
      x++;
    }
  }
  return x;
}

function manualMethod2(array, test) {
  let x = 0;
  let len = array.length;
  for (let i = 0; i < len; i++) {
    if (test(array[i])) {
      x++;
    }
  }
  return x;
}

function manualMethod3(array, test) {
  let x = 0;
  for (let i of array) {
    if (test(i)) {
      x++;
    }
  }
  return x;
}

Tests:

Filter length
const x = _.filter(window.array, i => i > .5).length; return x;
lodash sumBy
const x = _.sumBy(window.array, i => i > .5 ? 1 : 0); return x;
lodash filter chaining
const x = _(window.array).filter(i => i > .5).size(); return x;
manualMethod1
return manualMethod1(window.array);
manualMethod2 (with lambda function test)
return manualMethod2(window.array, i => i > .5);
manualMethod3 (for-each loop, with lambda function test)
return manualMethod3(window.array, i => i > .5);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Filter length
lodash sumBy
lodash filter chaining
manualMethod1
manualMethod2 (with lambda function test)
manualMethod3 (for-each loop, with lambda function test)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4.1 Safari/605.1.15

Browser/OS: Safari 17 on Mac OS X 10.15.7

View result in a separate tab

manualMethod2 (with lambda function test)

359/s

manualMethod1

355/s

lodash sumBy

354/s

manualMethod3 (for-each loop, with lambda function test)

328/s

lodash filter chaining

212/s

Filter length

210/s

View exact numbers

Test name	Executions per second
✓ manualMethod2 (with lambda function test)	359 Ops/sec
manualMethod1	355 Ops/sec
lodash sumBy	354 Ops/sec
manualMethod3 (for-each loop, with lambda function test)	328 Ops/sec
lodash filter chaining	212 Ops/sec
Filter length	210 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what is being tested, compared, and their pros and cons.

**Benchmark Overview**

The benchmark tests the performance of three methods to count the number of elements in an array that meet a certain condition:

1. Manual loop-based method (`manualMethod1`)
2. Lodash `filter()` method with `.length` property access (`lodash filter().length`)
3. Lodash `sumBy()` method (`lodash sumBy`)
4. Lodash `filter()` method with `.size` property access (`lodash filter().size`)
5. Manual loop-based method with a lambda function test (`manualMethod2`)
6. Manual loop-based method using a for-each loop and a lambda function test (`manualMethod3`)

**What is being tested?**

The benchmark tests the execution speed of these six methods on large arrays (500,000 elements). The results are reported in executions per second.

**Comparison of options:**

1. **Manual loop-based method (`manualMethod1`) vs Manual loop-based method with lambda function test (`manualMethod2`):**
	* Both methods use a simple for loop to iterate through the array.
	* However, `manualMethod2` uses a lambda function as a test condition, which can be more readable and concise than a traditional if statement. Performance-wise, both methods should be similar, but `manualMethod2` might have slight advantages due to the shorter code length.
2. **Lodash `filter()` method with `.length` property access (`lodash filter().length`) vs Lodash `sumBy()` method:**
	* Both methods are optimized for performance by using the corresponding properties on the resulting filtered or summed array.
	* However, `sumBy()` is generally faster than filtering followed by length checking because it avoids an additional iteration and property lookup. On the other hand, `filter()` can be more intuitive to use when dealing with large arrays.
3. **Lodash `filter()` method with `.size` property access (`lodash filter().size`) vs Lodash `sumBy()` method:**
	* Similar to the previous comparison, but this time using a different approach for filtering and counting elements.

**Pros and cons of each approach:**

1. Manual loop-based methods:
	* Pros: Can be more intuitive to use, especially for smaller arrays or when dealing with complex conditions.
	* Cons: Generally slower due to the overhead of explicit loops and conditional statements.
2. Lodash `filter()` method with `.length` property access:
	* Pros: Fast, optimized performance, and concise code.
	* Cons: Requires understanding of array methods and property accesses.
3. Lodash `sumBy()` method:
	* Pros: Faster than filtering followed by length checking, more intuitive for summing elements.
	* Cons: Requires understanding of the `sumBy` function and its assumptions.

**Lodash filter() method with .size property access**

Pros:

* Fast
* Concise

Cons:

* More complex code due to additional iteration

Overall, Lodash's optimized methods (`filter()` and `sumBy`) are generally faster than manual loop-based approaches. However, the choice of method depends on the specific use case, personal preference, and readability considerations.