Benchmark: Lodash filter 1 000 000

HTML Preparation code:

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

Script Preparation code:

const arr = [];
for(let i=0; i < 1000000; i++){
  arr.push({ id: _.random(0, 5) });
}
function Arr(){
  return arr;
}

Tests:

Arrow Function Filter
_.filter(Arr(), (i) => i.id === 5);
Prop
_.filter(Arr(), 'id', 5);
Object
_.filter(Arr(), {id: 5});
Filter Prototype
Arr().filter((i) => i.id === 5);
Explicit Filter Prototype
Array.prototype.filter.call(Arr(), (i) => i.id === 5);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Arrow Function Filter
Prop
Object
Filter Prototype
Explicit Filter Prototype

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript microbenchmarks is essential to understand how different approaches can affect the execution time of various functions.

**Benchmark Setup**

The provided JSON represents a benchmark for measuring the performance of Lodash's `filter` function with different input types: arrow functions, objects, and explicit prototype calls. The test case setup includes:

1. Preparing an array of 1 million elements with random IDs using JavaScript.
2. Creating a script that returns this array (`Arr()`).
3. Including the necessary Lodash library (`lodash.js`) via a CDN.

**Comparison Options**

The benchmark compares four different approaches for filtering the array:

1. **Arrow Function Filter**: `_.filter(Arr(), (i) => i.id === 5);`
2. **Prop**: `_.filter(Arr(), 'id', 5);` (using the second argument to specify the property name)
3. **Object**: `_.filter(Arr(), {id: 5});` (using an object with a single property as the filter predicate)
4. **Filter Prototype**: `Arr().filter((i) => i.id === 5);`
5. **Explicit Filter Prototype**: `Array.prototype.filter.call(Arr(), (i) => i.id === 5);`

**Pros and Cons of Each Approach**

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

1. **Arrow Function Filter**:
	* Pros: concise, readable, and efficient.
	* Cons: may not be supported in older browsers or environments that don't support arrow functions.
2. **Prop**:
	* Pros: allows specifying the property name as a string, which can be useful for certain use cases.
	* Cons: may lead to ambiguity if multiple properties with the same name exist, and it's less readable than using an object-based filter predicate.
3. **Object**:
	* Pros: provides a clear and concise way to specify complex filter predicates using objects.
	* Cons: can be verbose for simple predicates, and it may not be as efficient as using arrow functions or the `Prop` method.
4. **Filter Prototype**:
	* Pros: allows chaining multiple filters together, which can be useful in certain scenarios.
	* Cons: requires calling `Array.prototype.filter()` explicitly, which can lead to code duplication.
5. **Explicit Filter Prototype**:
	* Pros: provides a clear and explicit way to call the filter method on an array prototype.
	* Cons: may lead to boilerplate code, as you need to use `call()` to invoke the filter method.

**Library and Special JS Features**

Lodash is a popular JavaScript library that provides utility functions for tasks like filtering arrays. In this benchmark, Lodash's `filter` function is used in different ways to test its performance.

There are no special JavaScript features or syntaxes mentioned in this benchmark setup. If you're interested in exploring other features or approaches, feel free to ask!

**Alternatives**

If you're looking for alternatives to Lodash or want to explore other filtering libraries, here are a few options:

1. **Built-in Array.prototype.filter()**: Most modern browsers and environments have built-in support for `Array.prototype.filter()` which can be used as an alternative to Lodash's `filter` function.
2. **Underscore.js**: Another popular JavaScript utility library that provides a `filter` function, similar to Lodash.
3. **Moment.js**: A library specifically designed for working with dates and times, but it also includes a filtering mechanism (`_.filter()`).
4. **Custom implementations**: Depending on your specific use case, you might be able to create an efficient custom implementation using native JavaScript or other libraries.

I hope this explanation helps!

Latest run results:

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

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

Browser/OS: Chrome 83 on Windows

View result in a separate tab

Test name	Executions per second
Arrow Function Filter	221.2 Ops/sec
Prop	39.2 Ops/sec
Object	57.1 Ops/sec
Filter Prototype	57.0 Ops/sec
Explicit Filter Prototype	56.8 Ops/sec

Related benchmarks:

Lodash filter 1 000 000 (version: 0)

Comparing performance of: Arrow Function Filter vs Prop vs Object vs Filter Prototype vs Explicit Filter Prototype

Created: 4 years ago by: Guest

Jump to the latest result

Arrow Function Filter

Prop

Object

Filter Prototype

Explicit Filter Prototype

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