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)

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: 2 years ago by: Registered User

Jump to the latest result

HTML Preparation code:

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

AخA
 
<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;
}

​x
 
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;
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;

 
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;
const x = _(window.array).filter(i => i > .5).size();
return x;
manualMethod1
return manualMethod1(window.array);
return manualMethod1(window.array);
manualMethod2 (with lambda function test)
return manualMethod2(window.array, i => i > .5);
return manualMethod2(window.array, i => i > .5);
manualMethod3 (for-each loop, with lambda function test)
return manualMethod3(window.array, i => i > .5);
return manualMethod3(window.array, i => i > .5);

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
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: 11 months 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

Test name	Executions per second
Filter length	210.1 Ops/sec
lodash sumBy	354.1 Ops/sec
lodash filter chaining	212.5 Ops/sec
manualMethod1	355.1 Ops/sec
manualMethod2 (with lambda function test)	358.8 Ops/sec
manualMethod3 (for-each loop, with lambda function test)	328.4 Ops/sec

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

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:

Manual loop-based method (manualMethod1)
Lodash filter() method with .length property access (lodash filter().length)
Lodash sumBy() method (lodash sumBy)
Lodash filter() method with .size property access (lodash filter().size)
Manual loop-based method with a lambda function test (manualMethod2)
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:

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

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.
Lodash filter() method with .length property access:
- Pros: Fast, optimized performance, and concise code.
- Cons: Requires understanding of array methods and property accesses.
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.

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.

Related benchmarks: