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>

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

​x
 
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);
filterLodash(array3);
filter ts n=10000
filterLodash(array4);
filterLodash(array4);
filter ts n=100000
filterLodash(array5);
filterLodash(array5);
filter ts n=1000000
filterLodash(array6);
filterLodash(array6);
filter ts n=10000000
filterLodash(array7);
filterLodash(array7);
filter js n=1000
filterTS(array3);
filterTS(array3);
filter js n=10000
filterTS(array4);
filterTS(array4);
filter js n=100000
filterTS(array5);
filterTS(array5);
filter js n=1000000
filterTS(array6);
filterTS(array6);
filter js n=10000000
filterTS(array7);
filterTS(array7);

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

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

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

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.

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.

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: 4 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 7 months ago):