Benchmark: for in loop - MeasureThat.net

Script Preparation code:

var obj = {};
for (var i = 0; i < 20; i++) {
    obj[i] = i;
}

Tests:

for in loop
for (var k = 0; k < 1000; k++) { for (var i in obj) { console.log(obj[i]); } }
object keys loop
for (var k = 0; k < 1000; k++) { var keys = Object.keys(obj); for (var key of keys) { console.log(obj[key]); } }
object entries loop
for (var k = 0; k < 1000; k++) { const entries = Object.entries(obj); for (const [key, value] of entries) { console.log(value); } }
getownproperty
for (var k = 0; k < 1000; k++) { const propertyNames = Object.getOwnPropertyNames(obj); for (const propertyName of propertyNames) { console.log(obj[propertyName]); } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for in loop
object keys loop
object entries loop
getownproperty

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll dive into explaining the benchmark.

**What is being tested?**

The provided JSON represents two types of benchmarks:

1. **For-in loop**: This benchmark tests the performance of using a traditional for-in loop to iterate over an object's properties.
2. **Object keys, entries, and getOwnProperty methods**: These three benchmarks test different ways to access and iterate over an object's properties.

**Options compared:**

Here are the options being compared:

* **For-in loop**: Iterates over object properties using a traditional for-in loop (`for (var i in obj) { ... }`)
* **Object keys loop**: Iterates over an array of object keys obtained using `Object.keys(obj)` (`for (var key of Object.keys(obj)) { ... }`)
* **Object entries loop**: Iterates over an array of object key-value pairs obtained using `Object.entries(obj)` (`for (const [key, value] of Object.entries(obj)) { ... }`)
* **GetOwnProperty method**: Uses the `getOwnPropertyNames()` method to get an array of object property names and then iterates over it to access corresponding values (`for (const propertyName of Object.getOwnPropertyNames(obj)) { console.log(obj[propertyName]); }`)

**Pros and Cons:**

1. **For-in loop**:
	* Pros: Simple, widely supported, and can be efficient for small objects.
	* Cons: Can be slower and less efficient than other methods, especially for large objects or when iterating over a subset of properties.
2. **Object keys loop**:
	* Pros: Can be more efficient than the for-in loop, as it uses an array of keys and avoids checking each property's existence.
	* Cons: May not work correctly with non-enumerable properties (those that aren't part of the object's prototype chain).
3. **Object entries loop**:
	* Pros: Provides a way to access both key-value pairs and iterate over them, which can be more expressive than traditional for-in loops.
	* Cons: Requires using an array method (`Object.entries()`), which may not be supported in older browsers or environments.
4. **GetOwnProperty method**:
	* Pros: Allows direct access to property names without iterating over the entire object, making it potentially more efficient.
	* Cons: May not work correctly with non-enumerable properties and requires checking each property's existence.

**Library/Features Used:**

* None explicitly mentioned in the provided benchmarks. However, `Object.keys()`, `Object.entries()`, and `getOwnPropertyNames()` are built-in methods of the JavaScript Object prototype.
* No special JavaScript features or syntax are used in these benchmarks.

**Other Considerations:**

* The choice of iteration method can significantly impact performance, especially for large objects or when dealing with complex data structures.
* Modern browsers and JavaScript engines often optimize these iteration methods, so the actual performance differences between them may be smaller than expected.
* In general, it's essential to consider the specific requirements and constraints of your application when choosing an iteration method.

**Alternatives:**

Other iteration methods not tested in this benchmark include:

* **Using a traditional for loop**: `for (var i = 0; i < obj.length; i++) { ... }` (not as efficient or expressive as other methods)
* **Using `Object.values()` and `Array.prototype.forEach()`: `.forEach((value) => console.log(value));` (less efficient than object iteration methods, but may be more convenient for simple cases)

Keep in mind that the choice of iteration method depends on your specific use case, performance requirements, and compatibility constraints.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 111 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
for in loop	20.8 Ops/sec
object keys loop	19.7 Ops/sec
object entries loop	20.1 Ops/sec
getownproperty	17.4 Ops/sec

Related benchmarks:

for in loop (version: 2)

Comparing performance of: for in loop vs object keys loop vs object entries loop vs getownproperty

Created: one year ago by: Registered User

Jump to the latest result

for in loop

object keys loop

object entries loop

getownproperty

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