Benchmark: _.pickBy vs native vs ES6 Filter

Script Preparation code:

var obj = {};
for (let i = 0; i < 1000; i++) {
    const randomNum = Math.floor(Math.random() * 4);
    obj[i.toString()] =
        randomNum === 0 ? "undefined" : randomNum === 1 ? false : true;
}

Tests:

Lodash pickBy
_.pickBy(obj);
Native Filter
function pickBy(object) { const obj = {}; for (const key in object) { if (object[key]) { obj[key] = object[key]; } } return obj; } pickBy(obj)
ES6 Filter
Object.keys(obj).filter(key => { if (obj[key]) return obj[key] })

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Native Filter

43K/s

Lodash pickBy

25K/s

ES6 Filter

23K/s

Fastest: Native Filter (1.9x faster)

View exact numbers

✓ Native Filter: 42,772 ops/sec
• Lodash pickBy: 25,079 ops/sec
• ES6 Filter: 22,783 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash pickBy
Native Filter
ES6 Filter

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 132 on Android

View result in a separate tab

ES6 Filter

45K/s

Native Filter

32K/s

Lodash pickBy

12K/s

View exact numbers

Test name	Executions per second
✓ ES6 Filter	45,308 Ops/sec
Native Filter	31,693 Ops/sec
Lodash pickBy	11,827 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its test cases.

**Benchmark Definition**

The benchmark is testing three approaches to filter an object: `_.pickBy` (a function from the Lodash library), native JavaScript filter, and ES6 filter.

**Options Compared**

1. **Lodash _.pickBy**: This function takes two arguments - the object to be filtered (`object`) and a function that determines whether each property should be included in the output. The implementation uses a `for...in` loop to iterate over the object's properties, checking if the property value is truthy.
2. **Native JavaScript Filter**: This approach uses the built-in `Array.prototype.filter()` method to filter an array of keys. The implementation assumes that the object has been converted to an array of its own key-value pairs.
3. **ES6 Filter**: This approach uses the `Object.keys()` and `Array.prototype.filter()` methods to filter the object's properties.

**Pros and Cons**

1. **Lodash _.pickBy**:
	* Pros: Well-tested, widely supported, and optimized for performance. It is also a more concise way of filtering an object.
	* Cons: Requires Lodash library to be included in the test code, which may add overhead to the benchmark.
2. **Native JavaScript Filter**:
	* Pros: Fastest approach, as it leverages the built-in `Array.prototype.filter()` method. It also doesn't require any additional libraries or overhead.
	* Cons: Requires the object to be converted to an array of its own key-value pairs, which may introduce extra overhead for large objects.
3. **ES6 Filter**:
	* Pros: Easy to implement and understand, as it uses well-known methods from the ECMAScript standard.
	* Cons: May not be as optimized or performance-critical as the native filter approach.

**Library Used**

The Lodash library is used in the `_.pickBy` function. It provides a convenient way to perform common tasks, such as filtering objects, without having to write custom code.

**Special JS Features/Syntax**

None of the test cases use any special JavaScript features or syntax beyond what's standard in modern JavaScript implementations (ECMAScript 2022+).

**Alternatives**

If you want to explore alternative approaches to filtering an object, here are a few options:

* Using `Object.fromEntries()` and `Array.prototype.filter()`:
```javascript
const obj = Object.fromEntries(Object.entries(obj).filter(([key, value]) => value));
```
* Using a custom implementation with `for...in` loop and conditional statements:
```javascript
function filterObject(obj) {
  const result = {};
  for (const key in obj) {
    if (obj[key]) {
      result[key] = obj[key];
    }
  }
  return result;
}
```
Keep in mind that these alternatives may not be as optimized or efficient as the native JavaScript filter approach.

In summary, the benchmark is testing three approaches to filtering an object: Lodash _.pickBy, native JavaScript filter, and ES6 filter. The native filter approach is likely the fastest due to its use of built-in methods, while Lodash _.pickBy provides a more concise and convenient way to perform the task.

_.pickBy vs native vs ES6 Filter (version: 0) Benchmark.js

Comparing performance of: `Lodash pickBy vs Native Filter vs ES6 Filter`

Created: 3 years ago by: Guest

Go to the latest result

Lodash pickBy

Native Filter

ES6 Filter

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

_.pickBy vs native vs ES6 Filter (version: 0) Benchmark.js

Comparing performance of: Lodash pickBy vs Native Filter vs ES6 Filter

Created: 3 years ago by: Guest

Go to the latest result

Lodash pickBy

Native Filter

ES6 Filter

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `Lodash pickBy vs Native Filter vs ES6 Filter`