Benchmark: Obj.keys filter vs Obj.values reduce

Script Preparation code:

var INDICATOR = 'indicator';
var prunedInstances = {
  a: { state: { show: false }, id: 'boo' },
  b: { state: { show: true, display: INDICATOR }, id: 'foo' },
  c: { state: { show: true, display: INDICATOR }, id: 'fooC' },
  d: { state: { show: true, display: INDICATOR }, id: 'fooD' },
  e: { state: { show: false, display: INDICATOR }, id: 'fooE' },
};

var valsArr = Object.values(prunedInstances);
var keysArr = Object.keys(prunedInstances);

Tests:

reduce
valsArr.reduce((acc, cur) => { if (cur.state.show && cur.state.display === INDICATOR) { return cur.id; } }, []);
filter
keysArr.filter((id) => { const instance = prunedInstances[id]; return instance.state.show && instance.state.display === INDICATOR; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
filter

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 88 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
reduce	2828471.2 Ops/sec
filter	1202412.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what is tested in each benchmark.

**Benchmark Definition**

The first JSON represents the overall benchmark definition, which includes:

* `Name`: The name of the benchmark ("Obj.keys filter vs Obj.values reduce").
* `Description`: An empty description field (not specified).
* `Script Preparation Code`: A JavaScript code snippet that creates an object (`prunedInstances`) with various properties and values. This object is used as input for both test cases.
* `Html Preparation Code`: An empty HTML preparation code field (not specified).

**Individual Test Cases**

The second JSON represents two individual test cases, each defined by:

* `Benchmark Definition`: A JavaScript code snippet that performs a specific operation on the `prunedInstances` object. There are two test cases:
	1. `reduce`: This test case uses the `Array.prototype.reduce()` method to iterate over the `valsArr` array (which contains values from the `prunedInstances` object) and returns the first element that meets a certain condition.
	2. `filter`: This test case uses the `Array.prototype.filter()` method to filter the `keysArr` array (which contains keys from the `prunedInstances` object) based on a specific condition.

**Libraries Used**

In both test cases, the `Object.values()` and `Object.keys()` methods are used to extract values and keys from the `prunedInstances` object. These methods are built-in JavaScript functions that return arrays containing the values or keys of an object in a particular order.

No external libraries are explicitly mentioned in the provided code snippets.

**Special JS Features/Syntax**

There is no mention of special JavaScript features or syntax (e.g., async/await, Promises) in the provided code snippets.

**Pros and Cons of Different Approaches**

The choice between using `reduce()` and `filter()` depends on the specific use case and performance requirements. Here are some general pros and cons of each approach:

* `Reduce()`:
	+ Pros: Can be more efficient for certain types of data (e.g., arrays with a small number of elements) since it only requires a single pass through the data.
	+ Cons: Can be less intuitive and harder to read, especially for developers not familiar with this method.
* `Filter()`:
	+ Pros: Typically faster and more memory-efficient than `reduce()`, especially for large datasets.
	+ Cons: Requires an extra step to iterate over the filtered results (in this case, using another `Array.prototype` method).

**Other Alternatives**

If `reduce()` or `filter()` are not suitable for your use case, other alternatives could be:

* Using a custom loop with indexing and conditional statements.
* Employing more advanced data structures like sets or maps to improve performance.

Keep in mind that these alternatives may have different trade-offs in terms of readability, maintainability, and performance.

Related benchmarks:

Obj.keys filter vs Obj.values reduce (version: 0)

Comparing performance of: reduce vs filter

Created: 3 years ago by: Guest

Jump to the latest result

reduce

filter

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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