Benchmark: object.entries vs reduce

Script Preparation code:

var data = { ...Array.from(Array(10000).keys()) };

Tests:

Entries
const entries = [] for (const key of Object.keys(data)) { if (data[key] % 2 === 0) { entries.push([key, key.toString()]) } } Object.fromEntries(entries)
reduce
Object.keys(data) .reduce((ret, key) => { if (data[key] % 2 === 0) { ret[key] = key.toString(); } return ret }, {})

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Entries
reduce

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
Entries	534.8 Ops/sec
reduce	714.7 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 benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares two approaches to iterate over an object's entries: using `Object.entries()` with `Array.from()` and `reduce()`, and using `Object.keys()` with `reduce()`.

**Options Compared**

Two options are compared:

1. **`Object.entries()` with `Array.from()` and `reduce()`**: This approach uses the `entries()` method to get an array of key-value pairs, converts it to an array using `Array.from()`, and then uses `reduce()` to iterate over the values.
2. **`Object.keys()` with `reduce()`**: This approach uses the `keys()` method to get an array of keys, and then uses `reduce()` to iterate over the keys.

**Pros and Cons**

* **`Object.entries()` with `Array.from()` and `reduce()`**:
	+ Pros: more explicit and readable code; avoids the need for manual iteration.
	+ Cons: may be slower due to the overhead of converting an array to a new array using `Array.from()`.
* **`Object.keys()` with `reduce()`**:
	+ Pros: potentially faster, as it avoids the conversion step.
	+ Cons: less explicit and readable code; requires manual iteration.

**Library**

None.

**Special JS Feature or Syntax**

The benchmark does not use any special JavaScript features or syntax.

**Test Users Special Case**

None.

**Other Considerations**

The benchmark is likely designed to measure the performance of these two approaches in a general case, without considering edge cases or specific requirements. The test data is a simple object with 10,000 keys, and the benchmark measures the number of executions per second for each approach.

**Alternatives**

Some alternative approaches could be:

* Using `for...in` to iterate over the object's entries.
* Using a library like Lodash to simplify the iteration code.
* Using a specialized iterator or generator function to iterate over the object's entries.

However, these alternatives are not part of the current benchmark.

Related benchmarks:

object.entries vs reduce (version: 0)

Comparing performance of: Entries vs reduce

Created: 2 years ago by: Guest

Jump to the latest result

Entries

reduce

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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