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>

​x
 
<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 })

 
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]); }
for (var key in obj) {
console.log(obj[key]);
}
Object values
for(let value of Object.values(obj)){ console.log(value); }
for(let value of Object.values(obj)){
console.log(value);
}
Object keys forEach
Object.keys(obj).forEach(key => console.log(obj[key]));
Object.keys(obj).forEach(key => console.log(obj[key]));
Object entries forEach
Object.entries(obj).forEach(([key, value]) => console.log(key,'->',value));
Object.entries(obj).forEach(([key, value]) => console.log(key,'->',value));
object values forEach
Object.values(obj).forEach(value => console.log(value));
Object.values(obj).forEach(value => console.log(value));
_.forEach(_.values())
_.forEach(_.values(obj), value => console.log(value))
_.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]);
}

 
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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

Latest run results:

Run details: (Test run date: 11 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

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

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:

Traditional for...in loop
Using Object.values() method
Using Object.keys() method with forEach()
Using Object.entries() method with forEach()
Using Lodash's _.forEach(_.values()) method
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

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.
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.
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.
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.
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.
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!

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!

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: 11 months ago by: Guest

Jump to the latest result

For In

Object values

Object keys forEach

Object entries forEach

object values forEach

_.forEach(_.values())