Benchmark: For in vs Object.*.forEach vs Object.values for loop cached

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

AخA
 
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));

cached length for loop

    const length = Object.keys(obj).lenght
    for (var i = 0; i < length ; i++) { 
        console.log(Object.values(obj)[i])
    }

 
    const length = Object.keys(obj).lenght    for (var i = 0; i < length ; i++) {         console.log(Object.values(obj)[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
cached length for loop

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 108 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
For In	21.5 Ops/sec
Object values	22.4 Ops/sec
Object keys forEach	23.3 Ops/sec
Object entries forEach	18.3 Ops/sec
object values forEach	23.8 Ops/sec
cached length for loop	879.0 Ops/sec

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

Let's break down the provided benchmark and explain what's being tested, compared, and discussed.

Benchmark Overview

The benchmark measures the performance of different approaches for iterating over an object in JavaScript. Specifically, it compares the following methods:

for...in loop
Object.values() method
Object.keys() method with a forEach loop
Object.entries() method with a forEach loop
Caching the length of the object to avoid repeated lookups

Approaches Compared

The benchmark compares the performance of each approach in terms of executions per second (ExecutionsPerSecond). The approach with the highest value is considered faster.

Here's a brief explanation of each approach:

For...in loop: This traditional way of iterating over an object uses the in operator to check if a property exists.
**Object.values()method**: This method returns an array of values in the object, allowing for iteration using standard array methods likeforEach`.
**Object.keys()method with forEach**: Similar toObject.values()`, but iterates over the keys instead of values.
Object.entries()` method with forEach: Iterates over both keys and values as an array of [key, value] pairs.

Pros and Cons

Here are some pros and cons for each approach:

For...in loop
- Pros: Simple to implement, works well with legacy code.
- Cons: Can iterate over inherited properties, slower due to property lookup.
**Object.values()` method
- Pros: Fast, modern way of iterating over values, easy to use.
- Cons: Not suitable for objects with nested structures or non-string keys.
Object.keys()` method with forEach
- Pros: Similar performance to Object.values(), works well with objects that don't have inherited properties.
- Cons: Requires an additional method call (Object.keys()), slightly slower than Object.values() due to method overhead.
Object.entries()` method with forEach
- Pros: Works well with nested structures and non-string keys, easy to implement.
- Cons: Slowest of the four approaches due to the extra iteration step.

Library Usage

None of the provided methods rely on external libraries.

Special JavaScript Features/Syntax

There are no special features or syntax used in this benchmark. The focus is solely on comparing different iteration methods for objects.

Other Alternatives

If you're looking for alternative ways to iterate over an object, consider:

Using a library like Lodash: Offers utility functions for iterating over objects, including _.forEachObject().
Using a functional programming approach: Utilize the reduce() method or other functional programming techniques to process the object's values.

Keep in mind that this benchmark is focused on comparing different iteration methods, and the best choice ultimately depends on your specific use case and performance requirements.

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, compared, and discussed.

**Benchmark Overview**

The benchmark measures the performance of different approaches for iterating over an object in JavaScript. Specifically, it compares the following methods:

1. `for...in` loop
2. `Object.values()` method
3. `Object.keys()` method with a `forEach` loop
4. `Object.entries()` method with a `forEach` loop
5. Caching the length of the object to avoid repeated lookups

**Approaches Compared**

The benchmark compares the performance of each approach in terms of executions per second (ExecutionsPerSecond). The approach with the highest value is considered faster.

Here's a brief explanation of each approach:

1. **For...in loop**: This traditional way of iterating over an object uses the `in` operator to check if a property exists.
2. **Object.values()` method**: This method returns an array of values in the object, allowing for iteration using standard array methods like `forEach`.
3. **Object.keys()` method with forEach**: Similar to `Object.values()`, but iterates over the keys instead of values.
4. **Object.entries()` method with forEach**: Iterates over both keys and values as an array of [key, value] pairs.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **For...in loop**
	* Pros: Simple to implement, works well with legacy code.
	* Cons: Can iterate over inherited properties, slower due to property lookup.
2. **Object.values()` method
	* Pros: Fast, modern way of iterating over values, easy to use.
	* Cons: Not suitable for objects with nested structures or non-string keys.
3. **Object.keys()` method with forEach**
	* Pros: Similar performance to `Object.values()`, works well with objects that don't have inherited properties.
	* Cons: Requires an additional method call (`Object.keys()`), slightly slower than `Object.values()` due to method overhead.
4. **Object.entries()` method with forEach**
	* Pros: Works well with nested structures and non-string keys, easy to implement.
	* Cons: Slowest of the four approaches due to the extra iteration step.

**Library Usage**

None of the provided methods rely on external libraries.

**Special JavaScript Features/Syntax**

There are no special features or syntax used in this benchmark. The focus is solely on comparing different iteration methods for objects.

**Other Alternatives**

If you're looking for alternative ways to iterate over an object, consider:

1. **Using a library like Lodash**: Offers utility functions for iterating over objects, including `_.forEachObject()`.
2. **Using a functional programming approach**: Utilize the `reduce()` method or other functional programming techniques to process the object's values.

Keep in mind that this benchmark is focused on comparing different iteration methods, and the best choice ultimately depends on your specific use case and performance requirements.

Related benchmarks:

For in vs Object.*.forEach vs Object.values for loop cached (version: 0)

Comparing performance of: For In vs Object values vs Object keys forEach vs Object entries forEach vs object values forEach vs cached length for loop

Created: 2 years ago by: Guest

Jump to the latest result

For In

Object values

Object keys forEach

Object entries forEach

object values forEach