Benchmark: Array Filter - MeasureThat.net

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.10.1/lodash.min.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>

Script Preparation code:

function Rand(x) {
  return Math.floor(Math.random() * x);
}

const arr = R.map(x => { return {id: Rand(x)}; }, R.repeat(5, 1000));

function GetArray() { return arr; }

Tests:

Lodash prop
_.filter(GetArray(), 'id', 5);
Lodash arrow function
_.filter(GetArray(), i => i.id === 5);
Lodash Object
_.filter(GetArray(), {id: 5});
Array filter
GetArray().filter(i => i.id === 5);
Arrray prototype filter
Array.prototype.filter.call(GetArray(), i => i.id === 5);
Ramda filter
R.filter(i => i.id === 5, GetArray());
Array prototype filter with thisArg
GetArray().filter(i => i.id === 5, GetArray());

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash prop
Lodash arrow function
Lodash Object
Array filter
Arrray prototype filter
Ramda filter
Array prototype filter with thisArg

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

The provided JSON represents a benchmark test case for the `Array filter` function. The goal is to compare different approaches to filtering an array of objects in JavaScript.

**Benchmark Definition:**

The benchmark definition is provided in two parts:

1. **Script Preparation Code:** This code generates a random array of 5000 objects, each with an "id" property. The array is created using the `R.map` function from the Ramda library.
2. **Html Preparation Code:** Two JavaScript libraries are included: Lodash (version 3.10.1) and Ramda (version 0.25.0). These libraries provide various utility functions for working with arrays, objects, and more.

**Individual Test Cases:**

The benchmark test cases compare different ways to filter the array of objects:

1. **Lodash `_.filter`**: Uses the `_.filter` function from Lodash to filter the array.
2. **Lodash arrow function**: Uses an arrow function with a single parameter, `i => i.id === 5`, as the filtering criteria.
3. **Lodash Object**: Uses an object literal `{id: 5}` as the filtering criteria.
4. **Array `filter`**: Uses the built-in `filter` method on the array to filter it.
5. **Array prototype `filter.call`**: Uses the `call` method to call the `filter` method on the array, passing an arrow function with `thisArg` set to the `GetArray()` function.
6. **Ramda `R.filter`**: Uses the `R.filter` function from Ramda to filter the array.
7. **Array prototype `filter.call` with thisArg**: Similar to the previous point, but uses the `call` method again.

**Library and Purpose:**

* Lodash (version 3.10.1): A popular utility library for JavaScript, providing a wide range of functions for working with arrays, objects, strings, numbers, and more.
* Ramda (version 0.25.0): A functional programming library for JavaScript, providing a set of pure functions that can be composed together to solve problems.

**Special JS Features or Syntax:**

None mentioned explicitly in the benchmark definition.

**Pros and Cons:**

Here's a brief summary of the pros and cons of each approach:

* **Lodash `_.filter`**: Pros:
	+ Easy to use
	+ Fast performance
	Cons:
	+ Adds dependency on Lodash library
* **Lodash arrow function**: Pros:
	+ Simple and concise syntax
	+ Can be faster than other approaches due to optimization by the JavaScript engine
Cons:
	+ Requires understanding of arrow functions
* **Lodash Object**: Pros:
	+ Can be more readable in some cases (e.g., when using a complex filtering criteria)
Cons:
	+ May be slower due to object creation and lookup
* **Array `filter`**: Pros:
	+ Built-in method, no additional dependencies needed
	+ Fast performance
Cons:
	+ Requires understanding of the built-in `filter` method
* **Array prototype `filter.call` with thisArg**: Pros:
	+ Similar syntax to other approaches (e.g., arrow functions)
	+ Can be faster due to optimization by the JavaScript engine
Cons:
	+ May require additional setup or understanding of the `call` method
* **Ramda `R.filter`**: Pros:
	+ Functional programming approach, which can lead to more composable and reusable code
	+ Fast performance
Cons:
	+ Requires learning Ramda library

**Results:**

The benchmark results show that different approaches have varying performance characteristics. However, without specific numbers or analysis, it's difficult to say which approach is the best overall. The `Array filter` method typically seems to be the fastest, followed closely by Lodash arrow functions and Ramda `R.filter`.

Keep in mind that these results may vary depending on the specific use case, JavaScript engine version, and hardware platform.

Hope this answer helps you understand the world of JavaScript microbenchmarks!

Latest run results:

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

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

Browser/OS: Chrome 80 on Mac OS X 10.15.3

View result in a separate tab

Test name	Executions per second
Lodash prop	24227.9 Ops/sec
Lodash arrow function	74317.1 Ops/sec
Lodash Object	63380.4 Ops/sec
Array filter	335214.8 Ops/sec
Arrray prototype filter	63369.1 Ops/sec
Ramda filter	91033.3 Ops/sec
Array prototype filter with thisArg	349382.1 Ops/sec

Related benchmarks:

Array Filter (version: 10)

Lodash vs Array filter

Comparing performance of: Lodash prop vs Lodash arrow function vs Lodash Object vs Array filter vs Arrray prototype filter vs Ramda filter vs Array prototype filter with thisArg

Created: 6 years ago by: Registered User

Jump to the latest result

Lodash prop

Lodash arrow function

Lodash Object

Array filter

Arrray prototype filter

Ramda filter

Array prototype filter with thisArg

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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