Benchmark: test filter lodash/JS

HTML Preparation code:

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

Script Preparation code:

var n3 = 1000;
var n4 = 10000;
var n5 = 100000;
var n6 = 1000000;
var n7 = 10000000;
var array3 = [];
var array4 = [];
var array5 = [];
var array6 = [];
var array7 = [];
for(let i = 0; i < n3; i++) {
 array3.push(i); 
}
for(let i = 0; i < n4; i++) {
 array4.push(i); 
}
for(let i = 0; i < n5; i++) {
 array5.push(i); 
}
for(let i = 0; i < n6; i++) {
 array6.push(i); 
}
for(let i = 0; i < n7; i++) {
 array7.push(i); 
}

function filterLodash(arr) { 
    _.filter(arr, function (n) {
      return n % 2 == 0
    });
}

function filterTS(arr) { 
    arr.filter((n) => n % 2 == 0);
}

Tests:

filter ts n=1000
filterLodash(array3);
filter ts n=10000
filterLodash(array4);
filter ts n=100000
filterLodash(array5);
filter ts n=1000000
filterLodash(array6);
filter ts n=10000000
filterLodash(array7);
filter js n=1000
filterTS(array3);
filter js n=10000
filterTS(array4);
filter js n=100000
filterTS(array5);
filter js n=1000000
filterTS(array6);
filter js n=10000000
filterTS(array7);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
filter ts n=1000
filter ts n=10000
filter ts n=100000
filter ts n=1000000
filter ts n=10000000
filter js n=1000
filter js n=10000
filter js n=100000
filter js n=1000000
filter js n=10000000

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation of the benchmark.

**What is being tested?**

The benchmark tests two different approaches to filter an array: `filterLodash` (using Lodash) and `filterTS` (using JavaScript's built-in `Array.prototype.filter()` method).

**Options being compared**

The options being compared are:

* The Lodash library, specifically the `_filter()` function
* JavaScript's built-in `Array.prototype.filter()` method

**Pros and Cons of each approach:**

**Lodash (`filterLodash`):**

Pros:

* More concise and expressive code
* Handles edge cases (e.g., null, undefined, empty arrays) for you
* Often faster than vanilla JavaScript for large datasets

Cons:

* Additional overhead due to the Lodash library
* May not be as well-known or familiar to all developers

**JavaScript's built-in `Array.prototype.filter()` method:**

Pros:

* Native performance and lack of additional overhead
* Widely supported and well-documented
* Can be more intuitive for some developers

Cons:

* Requires more boilerplate code (e.g., callback function, initial condition)
* May not handle edge cases as robustly as Lodash

**Benchmark results:**

The benchmark results show that `filterTS` is generally faster than `filterLodash`, especially for smaller datasets. However, the performance difference decreases as the dataset size increases.

For example, on the `filterjs n=1000` test:

* `filterTS`: 5.44 ms
* `filterLodash`: 11.23 ms

And on the `filterts n=100000` test:

* `filterTS`: 2.35 ms
* `filterLodash`: 4.81 ms

However, it's essential to note that these results may vary depending on your specific use case, hardware, and software configuration.

**Conclusion:**

The choice between `filterLodash` and `filterTS` depends on your project's requirements, performance considerations, and team familiarity with the libraries. If you need a more concise and expressive solution, Lodash might be the better choice. However, if you prioritize native performance and simplicity, using JavaScript's built-in `Array.prototype.filter()` method could be the way to go.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.77 Safari/537.36

Browser/OS: Chrome 91 on Windows

View result in a separate tab

Test name	Executions per second
filter ts n=1000	383406.6 Ops/sec
filter ts n=10000	42157.8 Ops/sec
filter ts n=100000	3020.8 Ops/sec
filter ts n=1000000	238.4 Ops/sec
filter ts n=10000000	16.4 Ops/sec
filter js n=1000	442925.8 Ops/sec
filter js n=10000	49213.2 Ops/sec
filter js n=100000	3458.8 Ops/sec
filter js n=1000000	276.3 Ops/sec
filter js n=10000000	19.1 Ops/sec

Related benchmarks:

test filter lodash/JS (version: 0)

Comparing performance of: filter ts n=1000 vs filter ts n=10000 vs filter ts n=100000 vs filter ts n=1000000 vs filter ts n=10000000 vs filter js n=1000 vs filter js n=10000 vs filter js n=100000 vs filter js n=1000000 vs filter js n=10000000

Created: 3 years ago by: Guest

Jump to the latest result

filter ts n=1000

filter ts n=10000

filter ts n=100000

filter ts n=1000000

filter ts n=10000000

filter js n=1000

filter js n=10000

filter js n=100000

filter js n=1000000

filter js n=10000000

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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