Benchmark: for-in vs object.keys for sets

Script Preparation code:

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

Tests:

for-in
for (var i=10000; i > 0; i--) { const set = new Set() for (var key in obj) { set.add(key); } }
Object.keys
for (var i=10000; i > 0; i--) { const set = new Set(Object.keys(obj)) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
for-in
Object.keys

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmarking test cases and explain what's being tested, along with the pros and cons of each approach.

**Benchmark Definition**

The benchmark is designed to compare the performance of two approaches for iterating over an object's properties: `for-in` loop and `Object.keys()` method. The object in question, `obj`, contains 11 properties (keys) with values equal to 1.

**Script Preparation Code**

The script preparation code defines the `obj` object, which is used as input for both test cases.

**Html Preparation Code**

There is no HTML preparation code provided, which means that this benchmark focuses solely on JavaScript performance.

**Individual Test Cases**

There are two individual test cases:

1. **"for-in"**: This test case uses a traditional `for-in` loop to iterate over the object's properties and adds each property to a new `Set`.
2. **"Object.keys"**: This test case uses the `Object.keys()` method to get an array of the object's property names, which is then used to create a new `Set`.

**Comparison**

The two approaches differ in how they access and process the object's properties:

* `for-in` loop:
	+ Pros: Easy to understand and implement.
	+ Cons: Can be slower due to the overhead of iterating over an array-like object, which may not always represent the object's actual property names.
* `Object.keys()` method:
	+ Pros: Provides a direct access to the object's property names as an array, which can lead to better performance in modern browsers.
	+ Cons: May not be compatible with older browsers or environments that don't support this method.

**Library Usage**

Neither test case uses any external libraries. The `Set` data structure is built-in to JavaScript.

**Special JS Features/Syntax**

There are no special JavaScript features or syntax used in these benchmarking test cases.

**Other Alternatives**

Alternative approaches to iterating over an object's properties could include:

* Using a traditional `for` loop with array-like object iteration (`obj.keys()`)
* Using a `forEach()` loop
* Using the `entries()` method to get an iterator over the object's property names and values

However, these alternatives are not tested in this benchmark.

Overall, this benchmark provides a useful comparison between two common approaches to iterating over an object's properties in JavaScript.

Related benchmarks:

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

Comparing performance of: for-in vs Object.keys

Created: 4 years ago by: Guest

Jump to the latest result

for-in

Object.keys

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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