Benchmark: Reduce vs array.entries() vs for loop

Script Preparation code:

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

Tests:

reduce
Object.entries(data).reduce((acc, [k, v]) => { acc[k] = v.toString(); return acc; }, {});
array.entries()
const acc2 = {} for(const [index, value] of data.entries()) { acc2[index] = value.toString() }
for loop
const dataObject = Object.entries(data) const acc = {} for (let i = 0; i < dataObject.length; i++) { const [k, v] = dataObject[i]; acc[k] = v.toString() }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
reduce
array.entries()
for loop

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
reduce	3231.9 Ops/sec
array.entries()	7875.6 Ops/sec
for loop	3268.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Purpose**

The benchmark is designed to compare the performance of three different approaches for iterating over an array and accumulating values in an object:

1. `Array.entries()`
2. `for` loop
3. `Object.entries()` followed by `reduce()`

These approaches are compared because they serve similar purposes, but might have varying efficiency and syntax.

**Options Compared**

The three options being tested are:

1. **`Array.entries()`**: This method returns an iterator object that yields tuples containing the index and value of each element in the array.
2. **`for` loop**: A traditional loop using a variable to iterate over the array indices.
3. **`Object.entries()` + `reduce()`**: First, converts the array into an array of key-value pairs using `Object.entries()`, then uses `reduce()` to accumulate values in an object.

**Pros and Cons of Each Approach**

1. **`Array.entries()`**:
	* Pros: concise syntax, efficient iteration.
	* Cons: might be slower than traditional loops due to iterator overhead.
2. **`for` loop**:
	* Pros: well-known, efficient iteration, no additional library dependencies.
	* Cons: verbose syntax, can be error-prone if not handled carefully.
3. **`Object.entries()` + `reduce()`**:
	* Pros: concise syntax, can take advantage of JavaScript's built-in `reduce()` method.
	* Cons: might have higher overhead due to object creation and iteration.

**Library Used**

In this benchmark, the `Array` class is used as a library. It provides various methods for manipulating arrays, such as `entries()`, which is being tested here.

**Special JS Feature/Syntax**

There are no special JavaScript features or syntaxes mentioned in the benchmark definition or test cases. The code uses standard JavaScript syntax and built-in methods.

**Other Alternatives**

If you were to consider alternative approaches, you might also think about:

* Using `forEach()` with a callback function instead of `Array.entries()`.
* Utilizing modern JavaScript features like `map()` or `filter()` for array transformations.
* Implementing custom iteration logic using recursion or other techniques.

Keep in mind that the choice of approach ultimately depends on your specific use case, performance requirements, and personal preference.

Related benchmarks:

Reduce vs array.entries() vs for loop (version: 0)

Comparing performance of: reduce vs array.entries() vs for loop

Created: one year ago by: Guest

Jump to the latest result

reduce

array.entries()

for loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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