Benchmark: Teast reduce or entries filter fromEntries

Tests:

Test reduce
const state = { lorem: { test: 'ok', hidden: true }, ipsum: { test: 'ok' } } const filtered = Object.entries(state).reduce( (h, [name, value]) => (value.hidden ? h : { ...h, [name]: value }), {} )
Test entries
const state = { lorem: { test: 'ok', hidden: true }, ipsum: { test: 'ok' } } const filtered = Object.entries(state).filter(([key, value]) => !value.hidden) const rest = Object.fromEntries(filtered)
Test for in
const state = { lorem: { test: 'ok', hidden: true }, ipsum: { test: 'ok' } } let result = {} for (const prop in state) { if (!state[prop].hidden) { result = { ...result, [prop]: state[prop] } } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Test reduce
Test entries
Test for in

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36

Browser/OS: Chrome 108 on Linux

View result in a separate tab

Test name	Executions per second
Test reduce	4787309.0 Ops/sec
Test entries	1761748.4 Ops/sec
Test for in	29180840.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and its test cases for you.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided benchmark consists of three individual test cases, each designed to measure the performance of a specific approach for filtering entries in an object.

**Test Case 1: "Test reduce"**

The first test case uses the `reduce()` method to filter entries in an object. Here's what happens:

* The `Object.entries()` method returns an array of key-value pairs from the input object.
* The `reduce()` method iterates over this array, applying a callback function to each pair. In this case, the callback function checks if the value is hidden (`value.hidden ? h : { ...h, [name]: value }`).
* If the value is not hidden, it returns an object with the key and the non-hidden value.
* The `reduce()` method accumulates these objects in a single output object.

**Pros and Cons of using `reduce()`**

Using `reduce()` has its advantages:

* It's a concise way to perform transformations on arrays while accumulating results.
* It can be more efficient than other approaches, especially for small inputs.

However, it also has some drawbacks:

* The callback function is executed for each element in the array, which can lead to high overhead if the array is large.
* The accumulator object (`h`) needs to be carefully managed to avoid overwriting previous results.

**Test Case 2: "Test entries"**

The second test case uses the `filter()` method to filter entries in an object. Here's what happens:

* The `Object.entries()` method returns an array of key-value pairs from the input object.
* The `filter()` method iterates over this array, applying a callback function to each pair (`([key, value]) => !value.hidden`).
* If the value is not hidden, it includes the pair in the output array.
* Finally, `Object.fromEntries()` converts the filtered array back into an object.

**Pros and Cons of using `filter()`**

Using `filter()` has its advantages:

* It's often faster than `reduce()`, especially for large inputs, since it avoids the overhead of accumulating objects.
* The callback function is typically simpler to implement, as it only needs to check if the value is hidden.

However, it also has some drawbacks:

* The output object may not have the same structure as the original input object, since `filter()` returns an array of key-value pairs.
* If the filtered array is very large, it may consume a lot of memory.

**Test Case 3: "Test for in"**

The third test case uses a simple `for...in` loop to filter entries in an object. Here's what happens:

* The `Object.entries()` method returns an array of key-value pairs from the input object.
* The `for...in` loop iterates over this array, checking if each value is hidden (`!state[prop].hidden`).
* If the value is not hidden, it adds the key-value pair to the output object.

**Pros and Cons of using `for...in`**

Using `for...in` has its advantages:

* It's often faster than `reduce()` or `filter()`, especially for small inputs.
* The code is typically simpler to implement, as it only needs to check if each value is hidden.

However, it also has some drawbacks:

* The loop can be slower than other approaches for large inputs, since it iterates over the array using a primitive loop.
* The code may not be as concise or readable, especially for more complex transformations.

**Library: Object.entries()**

`Object.entries()` is a built-in JavaScript method that returns an array of key-value pairs from an object. It's used in all three test cases to extract the entries from the input object.

**Special JS feature/Syntax: None**

None of the test cases use any special JavaScript features or syntax, such as `async/await`, `let`, or `const` declarations.

**Alternatives**

Other alternatives for filtering entries in an object include:

* Using a library like Lodash, which provides a `filter()` method that can be used with objects.
* Using a function like `Array.prototype.filter.call()`, which can be used to filter arrays of key-value pairs.
* Using a simple loop with `Object.keys()` and indexing into the array.

Keep in mind that each approach has its own trade-offs, and the best choice will depend on the specific use case and performance requirements.

Related benchmarks:

Teast reduce or entries filter fromEntries (version: 0)

Comparing performance of: Test reduce vs Test entries vs Test for in

Created: one year ago by: Guest

Jump to the latest result

Test reduce

Test entries

Test for in

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