Benchmark: for-in hasOwnProperty vs object.keys test vs for-in

Script Preparation code:

var obj = {
  'a': 1,
  'b': 1,
  'c': 1,
  'd': 1,
  'e': 1,
  'f': 1,
  'g': 1
};

Tests:

for-in hasOwnProperty
for (var i=10000; i > 0; i--) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { console.log(key); } } }
Object.keys
for (var i=10000; i > 0; i--) { Object.keys(obj).forEach(key => console.log(key)); }
for-in
for (var i=10000; i > 0; i--) { for (var key in obj) { console.log(key); } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for-in hasOwnProperty
Object.keys
for-in

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 provided benchmark and explain what's being tested.

**Overview**

The test measures the performance of three different approaches to iterate over an object's keys:

1. `for-in` with `hasOwnProperty`
2. `Object.keys()`
3. Simple `for-in`

**What's being tested?**

Each test case is designed to run 10,000 iterations using a predefined object (`obj`) with six properties. The tests compare the execution time of each approach:

* **`for-in hasOwnProperty`**: Uses the `hasOwnProperty()` method to filter out inherited properties and only logs the keys that are directly owned by the object.
* **`Object.keys()`**: Utilizes the `Object.keys()` function, which returns an array of all keys in the object. This approach is expected to be faster since it doesn't require filtering.
* **Simple `for-in`**: Iterates over all properties using the `for-in` loop without any filtering or optimization.

**Pros and Cons**

1. **`for-in hasOwnProperty`**:
	* Pros: It filters out inherited properties, which can improve performance for large objects with complex inheritance hierarchies.
	* Cons: The filtering step introduces additional overhead, making it potentially slower than `Object.keys()` for simple cases.
2. **`Object.keys()`**:
	* Pros: Returns all keys in an array, allowing for easier iteration and filtering (in this case, no filtering is needed).
	* Cons: May incur a higher overhead due to the function call and array creation.
3. **Simple `for-in`**:
	* Pros: Simple and straightforward implementation with minimal overhead.
	* Cons: Iterates over all properties without any filtering or optimization, potentially leading to slower performance for large objects.

**Library/Library Purpose**

The test uses the `Object.keys()` function from the ECMAScript Standard Library. This function is a built-in method that returns an array of strings containing the property names in the specified object (in this case, `obj`).

**Special JS Features/Syntax**

There are no special JavaScript features or syntaxes being tested in this benchmark.

**Other Alternatives**

If you're looking for alternative approaches to iterate over objects, consider:

* **Using a custom loop**: You can write a simple loop using the `in` operator and string comparison to achieve similar results.
* **Using a library like Lodash**: The Lodash library provides a `keys()` function that is equivalent to `Object.keys()`.
* **Using a different data structure**: If you're dealing with large objects, you might consider using a more efficient data structure like a trie or an indexed object.

Keep in mind that these alternatives may not be optimized for performance and should be carefully evaluated based on your specific use case.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36

Browser/OS: Chrome 105 on Windows

View result in a separate tab

Test name	Executions per second
for-in hasOwnProperty	3.3 Ops/sec
Object.keys	3.1 Ops/sec
for-in	4.0 Ops/sec

Related benchmarks:

for-in hasOwnProperty vs object.keys test vs for-in (version: 0)

Comparing performance of: for-in hasOwnProperty vs Object.keys vs for-in

Created: 2 years ago by: Guest

Jump to the latest result

for-in hasOwnProperty

Object.keys

for-in

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