Benchmark: _pickBy vs native Object.entries + filter

HTML Preparation code:

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

Script Preparation code:

var obj = Array(1000)
  .fill()
  .reduce((acc, curr, i) => {
    acc[i] = i;
    return acc;
  }, {});
var predicate = v => v % 2 === 0;

Tests:

_.pickBy
_.pickBy(obj, predicate);
filter
Object.entries(obj).filter(([_, v]) => predicate(v));
reduce
Object.entries(obj).reduce((acc, [k, v]) => { if (predicate(v)) acc[k] = v; return acc; }, {});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
_.pickBy
filter
reduce

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 world of JavaScript microbenchmarks.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmark for three different approaches: `_.pickBy` (using Lodash), `Object.entries + filter`, and `Object.entries + reduce`. Our goal is to understand what's being tested, the pros and cons of each approach, and other considerations.

**Benchmark Definition**

The benchmark definition is a JavaScript code snippet that sets up an object `obj` with 1000 properties and fills them with values from 0 to 999. A predicate function `predicate` is also defined, which checks if a value is even (i.e., `v % 2 === 0`). The goal is to filter or pick specific properties from the `obj` based on this predicate.

**Approaches**

We have three approaches being compared:

1. **_.pickBy**: Using Lodash's `pickBy` function, which takes an object and a callback function as arguments. It returns a new object with only the properties that pass the test implemented by the provided function.
2. **Object.entries + filter**: This approach uses the `Array.prototype.filter()` method to create a new array with only the elements for which the predicate function returns `true`. Then, it uses the `Object.fromEntries()` method to convert the filtered array back into an object.
3. **Object.entries + reduce**: Similar to the previous approach, but instead of using `filter()`, we use the `Array.prototype.reduce()` method to create a new object with only the properties that pass the test implemented by the predicate function.

**Pros and Cons**

Here's a brief summary of each approach:

* **_.pickBy**:
	+ Pros: Fast and concise, as it relies on Lodash's optimized implementation.
	+ Cons: Requires an additional library (Lodash) to be included in the test environment. This might add overhead due to HTTP request latency.
* **Object.entries + filter**:
	+ Pros: Does not require any external libraries, making it a lightweight and self-contained option.
	+ Cons: May have higher performance overhead compared to using Lodash's optimized implementation.
* **Object.entries + reduce**:
	+ Pros: Similar to `filter()`, but with the added benefit of being able to accumulate values in the accumulator object (in case you need to do so).
	+ Cons: Also has a potential performance overhead compared to using Lodash's optimized implementation.

**Other Considerations**

* **Performance**: The performance differences between these approaches might be negligible for small objects like this one. However, as the size of the object grows, the performance differences may become more pronounced.
* **Readability and Maintainability**: Using a library like Lodash can make your codebase more readable, but it also adds an extra layer of complexity due to dependencies.

**Library: Lodash**

Lodash is a popular JavaScript utility library that provides a wide range of functions for tasks such as array manipulation, object transformation, and functional programming. The `pickBy` function in particular is designed to be fast and efficient while still being easy to use.

**Special JS Feature/Syntax**

None mentioned explicitly, but note that `Object.fromEntries()` was introduced in ECMAScript 2015 (ES6) as a part of the standard library. It's a modern feature that allows you to create objects from arrays using a more concise syntax.

**Alternatives**

If you want to explore other alternatives, here are a few options:

* **Array.prototype.filter()**: This is a built-in method in JavaScript that creates a new array with only the elements for which the predicate function returns `true`. However, as mentioned earlier, it might have higher performance overhead compared to using Lodash's optimized implementation.
* **Object.keys() + Array.prototype.reduce()**: Another approach could be to use `Object.keys()` to get an array of property names and then use `Array.prototype.reduce()` to create a new object with only the properties that pass the test implemented by the predicate function.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
_.pickBy	13150.6 Ops/sec
filter	8764.8 Ops/sec
reduce	8368.3 Ops/sec

Related benchmarks:

_pickBy vs native Object.entries + filter (version: 0)

Based on this test: https://www.measurethat.net/Benchmarks/Show/7332/0/pickby-vs-native But using filter instead of reduce

Comparing performance of: _.pickBy vs filter vs reduce

Created: one year ago by: Guest

Jump to the latest result

_.pickBy

filter

reduce

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