Benchmark: object.keys + lookup + for loop vs. object.entries.forEach

Script Preparation code:

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

Tests:

Object.entries.forEach
for (let i=10000; i > 0; i--) { Object.entries(obj).forEach(([key, value]) => console.log(key, value)); }
Object.keys + lookup + for loop
for (let i=10000; i > 0; i--) { const keys = Object.keys(obj); for (let i = 0; i < keys.length; i++) { const key = keys[i]; const value = obj[key]; console.log(key, value); } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.entries.forEach
Object.keys + lookup + for loop

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 113 on Windows

View result in a separate tab

Test name	Executions per second
Object.entries.forEach	2.8 Ops/sec
Object.keys + lookup + for loop	3.2 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided benchmark compares the performance of two approaches for iterating over an object's keys and looking up their corresponding values:

1. `Object.keys + lookup + for loop`
2. `object.entries.forEach`

**Approach 1: Object.keys + lookup + for loop**

This approach uses the `Object.keys()` method to get an array of the object's keys, then iterates over this array using a traditional `for` loop. For each key, it looks up the corresponding value in the object using the bracket notation (`obj[key]`) and logs the key-value pair to the console.

Pros:

* This approach is more explicit and allows for better control over the iteration process.
* It avoids the use of arrow functions, which can be optimized differently by JavaScript engines.

Cons:

* It requires an additional loop iteration to access each value, which can increase overhead.
* The `Object.keys()` method may not be as efficient as other methods (like `Object.entries()`) in some situations.

**Approach 2: object.entries.forEach**

This approach uses the `object.entries()` method to get an iterator over an array of key-value pairs, then calls the `forEach` method on this iterator. The arrow function passed to `forEach` extracts the key from each pair and logs it to the console.

Pros:

* This approach is more concise and eliminates the need for an additional loop iteration.
* It uses a more modern and efficient way to iterate over objects (which can be optimized by JavaScript engines).

Cons:

* It relies on the internal workings of `object.entries()` and `forEach`, which might not be as well-defined or consistent across different browsers and engines.
* The arrow function used in `forEach` can lead to a slight performance overhead due to its creation.

**Library: Object.keys()**

The `Object.keys()` method is a built-in JavaScript function that returns an array of the object's own enumerable property names. It has been available since ECMAScript 5 (2011).

**Special JS Feature/Syntax: None**

There are no special JavaScript features or syntax used in this benchmark.

**Other Alternatives**

If you wanted to compare other approaches, here are a few alternatives:

* Using `for...in` instead of `Object.keys()` and bracket notation:
```javascript
for (let i = 0; i < keys.length; i++) {
  const key = keys[i];
  for (const value in obj) {
    if (value === key) {
      console.log(key, obj[value]);
      break;
    }
  }
}
```
* Using `reduce()` instead of `forEach`:
```javascript
Object.keys(obj).reduce((acc, key) => acc + `${key}: ${obj[key]}\n`, '');
```
Keep in mind that these alternatives might not provide the same performance or readability benefits as the original approaches.

**Benchmark Preparation Code**

The provided benchmark preparation code creates an object `obj` with 10 properties and sets their values to 1. This object is used for both test cases.

Related benchmarks:

object.keys + lookup + for loop vs. object.entries.forEach (version: 0)

Compares the speed of getting an array of keys and looking up the object values with those keys (in a loop) with simply calling `.forEach` on `object.entries()`

Comparing performance of: Object.entries.forEach vs Object.keys + lookup + for loop

Created: one year ago by: Guest

Jump to the latest result

Object.entries.forEach

Object.keys + lookup + for loop

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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