Benchmark: Object.keys filter vs Object.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' },
  aa: { state: { show: false }, id: 'boo' },
  aaa: { state: { show: false }, id: 'boo' },
  aaaa: { state: { show: false }, id: 'boo' },
  aaaaa: { state: { show: false }, id: 'boo' },
};

Tests:

reduce
Object.values(prunedInstances).reduce((acc, cur) => { if (cur.state.show && cur.state.display === INDICATOR) { return cur.id; } }, []);
filter
Object.keys(prunedInstances).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:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested, compared options, pros and cons of those approaches, and other considerations.

**Benchmark Definition**

The benchmark is comparing two approaches to filter an object:

1. `Object.values(prunedInstances).filter((id) => {\r\n  const instance = prunedInstances[id];\r\n  return instance.state.show && instance.state.display === INDICATOR;\r\n });`
2. `Object.keys(prunedInstances).reduce((acc, cur) => {\r\n  if (cur.state.show && cur.state.display === INDICATOR) {\r\n    return cur.id;\r\n  }\r\n}, []);`

**What's being tested?**

The benchmark is testing the performance difference between two approaches to filter an object:

1. `filter` method: This approach iterates over the keys of the object and checks each key if it meets the condition.
2. `reduce` method: This approach accumulates values from the object into an accumulator array, filtering out values that don't meet the condition.

**Options compared**

The benchmark is comparing two options:

1. **Filter**: Iterating over the keys of the object using `Object.keys()` and then checking each key if it meets the condition.
2. **Reduce**: Accumulating values from the object into an accumulator array, filtering out values that don't meet the condition.

**Pros and Cons**

**Filter:**

Pros:

* Easy to understand and implement
* Can be used for simple filtering tasks

Cons:

* Has to iterate over all keys of the object, which can lead to performance issues with large objects.
* May not be as efficient as `reduce` for certain use cases.

**Reduce:**

Pros:

* Can handle large objects efficiently by accumulating values into an array.
* Can be more concise than `filter` for complex filtering tasks.

Cons:

* Requires understanding of the accumulator function and how it handles initial value.
* May have a higher learning curve compared to `filter`.

**Other Considerations**

Both approaches assume that the object has multiple properties with `show` and `display` values that can be used for filtering. If the object structure is different, one approach might be more suitable than the other.

Additionally, this benchmark does not account for edge cases such as:

* Empty objects or arrays
* Objects with null or undefined values
* Objects with non-string keys

**Library Usage**

In this benchmark, `Object.keys()` and `Object.values()` are built-in JavaScript methods. The `reduce()` method is also a built-in JavaScript method.

**Special JS Feature or Syntax**

The benchmark uses the `=>` syntax for arrow functions, which is a shorthand for function expressions introduced in ECMAScript 2015 (ES6). This syntax allows for concise and readable code.

Overall, this benchmark provides a good comparison of two approaches to filtering an object. It helps developers understand the performance characteristics of each approach and choose the most suitable method depending on their use case.

Related benchmarks:

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

Comparing performance of: reduce vs filter

Created: 5 years ago by: Guest

Jump to the latest result

reduce

filter

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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