Benchmark: Iterate over object

Script Preparation code:

var o = {};

for(var i=0; i<5000; i++) {
  o[i] = i;
}

Tests:

for..in with hasOwnProperty()
for (const key in o) { if (o.hasOwnProperty(key)) { const element = o[key]; } }
for..in without hasOwnProperty()
for (const key in o) { const element = o[key]; }
Object.keys() + Array.forEach()
const keys = Object.keys(o); keys.forEach((key)=>{ const element = o[key]; })
Object.keys() + Array.for()
const keys = Object.keys(o); const length = keys.length; for (let k = 0; k < length; k++) { const element = o[keys[k]]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for..in with hasOwnProperty()
for..in without hasOwnProperty()
Object.keys() + Array.forEach()
Object.keys() + Array.for()

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):

LLMs can make mistakes. Check important info.

**What is being tested?**

The provided benchmark tests the performance of three different approaches to iterate over an object in JavaScript:

1. `for...in` with `hasOwnProperty()`: This approach uses the `hasOwnProperty()` method to check if each property exists in the object before accessing it.
2. `for...in` without `hasOwnProperty()`: This approach skips checking if a property exists using `hasOwnProperty()`.
3. Using `Object.keys()` and then iterating over the resulting array with `Array.forEach()` or `Array.for()`.

**Options being compared**

The benchmark compares the performance of these three approaches:

* **Approach 1: for...in with hasOwnProperty()**
	+ Pros:
		- This approach is more explicit and clear about its intent.
	+ Cons:
		- It may be slower due to the additional check `hasOwnProperty()`.
* **Approach 2: for...in without hasOwnProperty()**
	+ Pros:
		- This approach might be faster since it skips the unnecessary check.
	+ Cons:
		- It is less explicit and might lead to errors if not used carefully.
* **Approach 3: Object.keys() + Array.forEach() or Array.for()**
	+ Pros:
		- These approaches use modern JavaScript features and can be more efficient since they iterate directly over the object's properties.
	+ Cons:
		- They may require a higher level of expertise to understand and implement correctly.

**Library used**

The benchmark uses the `Object` library, which is a built-in part of the JavaScript language. The `Object.keys()` method returns an array-like object containing the property names of the given object.

**Special JS feature/syntax**

* None mentioned in this specific benchmark.

**Other considerations**

When choosing between these approaches, consider the following factors:

* Readability and maintainability: If you need to write code that is easy to understand and maintain, `for...in` with `hasOwnProperty()` might be a better choice.
* Performance: If speed is crucial, using `Object.keys()` and iterating over the resulting array might provide a performance advantage.
* Modern JavaScript features: If you're familiar with modern JavaScript features like `Object.keys()` and `Array.forEach()`, you can take advantage of their efficiency.

**Alternatives**

Other approaches to iterate over an object in JavaScript include:

* Using `for...in` without `hasOwnProperty()`: While it's less explicit, this approach is often used when the order of iteration doesn't matter.
* Using a `Map` or `WeakMap` instead of an object: These data structures provide faster lookups and can be more efficient for large datasets.
* Using a library like Lodash or Ramda: These libraries provide utility functions that can simplify iteration over objects.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; rv:103.0) Gecko/20100101 Firefox/103.0

Browser/OS: Firefox 103 on Windows

View result in a separate tab

Test name	Executions per second
for..in with hasOwnProperty()	2496.3 Ops/sec
for..in without hasOwnProperty()	2457.4 Ops/sec
Object.keys() + Array.forEach()	7996.7 Ops/sec
Object.keys() + Array.for()	8815.0 Ops/sec

Related benchmarks:

Iterate over object (version: 1)

Various cases to iterate over given object

Comparing performance of: for..in with hasOwnProperty() vs for..in without hasOwnProperty() vs Object.keys() + Array.forEach() vs Object.keys() + Array.for()

Created: 6 years ago by: Registered User

Jump to the latest result

for..in with hasOwnProperty()

for..in without hasOwnProperty()

Object.keys() + Array.forEach()

Object.keys() + Array.for()

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 28 days ago):