Benchmark: For in vs Object.*.forEach vs Object.values vs _.forEach(_.values vs n=arr.length

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/lodash/4.16.0/lodash.min.js"></script>

Script Preparation code:

var obj = new Object()
var keys = (new Array(10000)).fill(0).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));
_.forEach(_.values())
_.forEach(_.values(obj), value => console.log(value))
n=arr.length
const arr = Object.values(obj); for (var i=0, n=arr.length; i < n; ++i){ console.log(arr[i]); }

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
_.forEach(_.values())
n=arr.length

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 and explain what's being tested, compared, and their pros/cons.

**Benchmark Overview**

The benchmark compares six different approaches to iterate over an object:

1. Traditional `for...in` loop
2. Using `Object.values()` method
3. Using `Object.keys()` method with `forEach()`
4. Using `Object.entries()` method with `forEach()`
5. Using Lodash's `_.forEach(_.values())` method
6. Manual iteration using an index variable

**What's being tested?**

Each test case measures the performance of a specific approach to iterate over the object, which contains 10,000 properties (keys) with values from 1 to 10,000.

**Comparison options**

Here are the compared options:

* `for...in` loop
* Using `Object.values()` method
* Using `Object.keys()` method with `forEach()`
* Using `Object.entries()` method with `forEach()`
* Lodash's `_.forEach(_.values())` method
* Manual iteration using an index variable (`n=arr.length`)

**Pros and Cons of each approach**

1. **Traditional `for...in` loop**:
	* Pros: Easy to understand, no additional libraries required.
	* Cons: Can be slower due to the overhead of iterating over property names, which may not match the expected iteration order.
2. **Using `Object.values()` method**:
	* Pros: Fast and efficient, as it returns a direct array of values without the need for property names.
	* Cons: Requires modern JavaScript (ES6+) support and may not work in older browsers or environments.
3. **Using `Object.keys()` method with `forEach()`**:
	* Pros: Similar performance to `Object.values()`, but allows access to both keys and values.
	* Cons: May be slower than `Object.values()` due to the additional overhead of iterating over property names.
4. **Using `Object.entries()` method with `forEach()`**:
	* Pros: Similar performance to previous options, but provides direct access to both keys and values as arrays.
	* Cons: Requires modern JavaScript (ES6+) support and may not work in older browsers or environments.
5. **Lodash's `_.forEach(_.values())` method**:
	* Pros: Provides a convenient way to iterate over an array of values, with the added benefit of Lodash's optimization and caching.
	* Cons: Requires an additional library dependency (Lodash) and may be slower than native JavaScript implementations.
6. **Manual iteration using an index variable (`n=arr.length`)**:
	* Pros: Allows for fine-grained control over iteration, which can be useful in certain situations.
	* Cons: Can be error-prone, verbose, and slower due to the need to manually increment the index variable.

**Other considerations**

The benchmark also considers the following factors:

* Device platform (Desktop vs. unknown)
* Browser version (Chrome 124)
* Operating system (Mac OS X 10.15.7)

These factors may affect the performance of each approach, but are not directly related to the iteration logic itself.

I hope this explanation helps clarify what's being tested and compared in the JavaScript microbenchmark!

Latest run results:

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

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

Browser/OS: Chrome 124 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
For In	35.8 Ops/sec
Object values	35.2 Ops/sec
Object keys forEach	40.8 Ops/sec
Object entries forEach	33.7 Ops/sec
object values forEach	43.1 Ops/sec
_.forEach(_.values())	35.5 Ops/sec
n=arr.length	35.9 Ops/sec

Related benchmarks:

For in vs Object.*.forEach vs Object.values vs _.forEach(_.values vs n=arr.length (version: 0)

Comparing performance of: For In vs Object values vs Object keys forEach vs Object entries forEach vs object values forEach vs _.forEach(_.values()) vs n=arr.length

Created: 6 months ago by: Guest

Jump to the latest result

For In

Object values

Object keys forEach

Object entries forEach

object values forEach

_.forEach(_.values())

n=arr.length

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