Benchmark: For in vs Object.*.forEach vs Object.values #3

Script Preparation code:

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

Tests:

Object.values for of
let result; for(let value of Object.values(obj)){ result = value; }
Object.keys forEach
let result; Object.keys(obj).forEach(key => result = obj[key]);
Object.entries forEach
let result; Object.entries(obj).forEach(([key, value]) => result = value);
Object.values forEach
let result Object.values(obj).forEach(value => result = value);
For in
let result; for (var key in obj) { result = obj[key]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.values for of
Object.keys forEach
Object.entries forEach
Object.values forEach
For in

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the JavaScript microbenchmark provided by MeasureThat.net.

**Benchmark Overview**

The benchmark tests four different ways to access properties of an object: `For in`, `Object.keys.forEach`, `Object.values forEach`, and `Object.entries forEach`. The test case uses a large object with 100,000 properties (keys) and assigns each key a value. The goal is to find the most efficient way to retrieve one of these values.

**Benchmark Definition**

The benchmark definition is provided as a JSON object:

```json
{
    "Name": "For in vs Object.*.forEach vs Object.values #3",
    "Description": null,
    "Script Preparation Code": "var obj = new Object()\r\nvar keys = (new Array(100000)).fill(0).map((x, i) => { return i + 1 })\r\nkeys.forEach((x) => { obj['prop' + x] = x })",
    "Html Preparation Code": null
}
```

This code creates an object `obj` with 100,000 properties and assigns each property a value. The script preparation code uses `Array.prototype.fill()` and `Array.prototype.map()` to generate the keys and assign values.

**Individual Test Cases**

The benchmark consists of four test cases:

1. **For in**: `for (var key in obj) { result = obj[key]; }`
2. **Object.keys.forEach**: `let result; Object.keys(obj).forEach(key => result = obj[key]);`
3. **Object.values for of**: `let result; for (let value of Object.values(obj)) { result = value; }`
4. **Object.values forEach**: `let result; Object.values(obj).forEach(value => result = value);`

These test cases use different approaches to access the properties of the object.

**Pros and Cons**

Here's a brief summary of each approach:

1. **For in**:
	* Pros: Simple, straightforward, and widely supported.
	* Cons: Can be slower due to the overhead of iterating over the prototype chain.
2. **Object.keys.forEach**:
	* Pros: Faster than `for in` since it avoids the prototype chain iteration.
	* Cons: Requires the `forEach()` method, which may not be supported in older browsers.
3. **Object.values for of**:
	* Pros: Fast and efficient using the new `for...of` loop syntax.
	* Cons: Limited support in older browsers (pre-ES6).
4. **Object.values forEach**:
	* Pros: Faster than `for in` since it uses an iterator, but similar to `Object.keys.forEach`.
	* Cons: Similar limitations as `Object.keys.forEach`.

**Other Considerations**

The benchmark results show that the fastest approach depends on the browser and device platform.

* `For in` is slower for Chrome 121 on desktop (Mac OS X).
* `Object.values for of` is significantly faster than the other approaches, but limited by older browsers.
* `Object.entries forEach` is slower due to its higher overhead compared to `for...of`.

**Library and Special JS Features**

None.

**Alternatives**

Other approaches that could be tested include:

1. Using `Reflect.ownKeys()` or `Object.keys()` with a custom iterator.
2. Using `Array.prototype.reduce()` or `Array.prototype.every()` instead of `forEach()`.
3. Compiling the JavaScript code to machine code using tools like V8 or SpiderMonkey.

Keep in mind that these alternatives might not be supported by older browsers or may have varying performance characteristics depending on the specific implementation.

Latest run results:

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

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

Browser/OS: Chrome 121 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.values for of	58.8 Ops/sec
Object.keys forEach	67.4 Ops/sec
Object.entries forEach	45.1 Ops/sec
Object.values forEach	57.3 Ops/sec
For in	70.4 Ops/sec

Related benchmarks:

For in vs Object.*.forEach vs Object.values #3 (version: 2)

Comparing performance of: Object.values for of vs Object.keys forEach vs Object.entries forEach vs Object.values forEach vs For in

Created: 10 months ago by: Registered User

Jump to the latest result

Object.values for of

Object.keys forEach

Object.entries forEach

Object.values forEach

For in

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