Benchmark: For in vs Object.*.forEach vs Object.values vs Array.forEach

Script Preparation code:

var obj = new Object()
var arr = (new Array(10000)).fill(0)
var keys = arr.map((x, i) => { return i + 1 })
keys.forEach((x) => { obj['prop' + x] = x })

Tests:

For In
for (var key in obj) { console.log(obj[key]); }
Object values
for(let value of Object.values(obj)){ console.log(value); }
Object keys forEach
Object.keys(obj).forEach(key => console.log(obj[key]));
Object entries forEach
Object.entries(obj).forEach(([key, value]) => console.log(key,'->',value));
object values forEach
Object.values(obj).forEach(value => console.log(value));
array foreach
arr.forEach(value => console.log(value));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For In
Object values
Object keys forEach
Object entries forEach
object values forEach
array foreach

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview**

The provided JSON represents a JavaScript microbenchmark test case on MeasureThat.net. The goal of this benchmark is to compare the performance of different ways to iterate over an object and an array.

**Benchmark Definition**

The benchmark definition is represented by two parts: `Script Preparation Code` and `Html Preparation Code`. However, in this case, both are empty, which means that no preparation code or HTML code is needed for the benchmark.

The script preparation code defines a JavaScript object `obj` and an array `arr`, which will be used as input to the benchmark. The keys of the object and values of the array are generated using the `map()` function.

**Individual Test Cases**

There are six individual test cases, each representing a different way to iterate over the object and/or array:

1. **For In**: Iterates over the object using the `for...in` loop.
2. **Object values**: Iterates over the object's values using `Object.values()`.
3. **Object keys forEach**: Iterates over the object's keys using `Object.keys()` and `forEach()`.
4. **Object entries forEach**: Iterates over the object's key-value pairs using `Object.entries()` and `forEach()`.
5. **object values forEach** (note: this is a typo in the original JSON, but it seems to be a variant of the "Object values" test case): Iterates over the object's values using `Object.values()` and `forEach()`.
6. **array foreach**: Iterates over the array using `arr.forEach()`.

**Comparison**

The comparison between these different approaches will measure their performance in terms of the number of executions per second.

**Pros and Cons**

Here are some pros and cons for each approach:

* **For In**: Pros: Simple to implement, works well with primitive values. Cons: Can be slower due to the overhead of iterating over property names.
* **Object values**: Pros: Efficient way to iterate over object values. Cons: May not work as expected with objects that have complex relationships between properties.
* **Object keys forEach** and **Object entries forEach**: Pros: Allow for more control over iteration, can be useful in certain scenarios. Cons: May introduce additional overhead due to the use of `forEach()`.
* **array foreach**: Pros: Simple to implement, works well with arrays. Cons: May not work as expected with objects that have complex relationships between properties.

**Other Considerations**

When choosing an iteration approach, consider the following:

* If you need to iterate over object or array values, use `Object.values()` or `arr.forEach()`.
* If you need more control over iteration, use `Object.keys()` or `Object.entries()`, but be aware of potential additional overhead.
* Avoid using `for...in` if possible, as it can introduce unnecessary overhead.

**Library Usage**

There is no explicit library usage in this benchmark. However, `Object.values()`, `Object.keys()`, and `Object.entries()` are all part of the ECMAScript standard, so they do not require any additional libraries.

**Special JS Features or Syntax**

None of the individual test cases use special JavaScript features or syntax beyond what is part of the ECMAScript standard.

Latest run results:

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

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

Browser/OS: Chrome 128 on Linux

View result in a separate tab

Test name	Executions per second
For In	11.2 Ops/sec
Object values	11.1 Ops/sec
Object keys forEach	13.0 Ops/sec
Object entries forEach	8.3 Ops/sec
object values forEach	8.8 Ops/sec
array foreach	12.0 Ops/sec

Related benchmarks:

For in vs Object.*.forEach vs Object.values vs Array.forEach (version: 0)

Comparing performance of: For In vs Object values vs Object keys forEach vs Object entries forEach vs object values forEach vs array foreach

Created: 2 months ago by: Guest

Jump to the latest result

For In

Object values

Object keys forEach

Object entries forEach

object values forEach

array foreach

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