Benchmark: My: Object.entries vs For In

Script Preparation code:

var ns = [1000, 10000, 100000];
var results = Array(ns.length); // 1.000 -> 10.000 -> 100.000 -> 1.000.000 -> 10.000.000
ns.forEach((n, i) => {
    results[i] = [...Array(n).keys()].reduce((acc, c) => {
        acc['k_' + String(c).padStart(10, '0')] = Math.random();
        return acc;
    }, {});
});
let sum = 0;

Tests:

N: 1000 Object.entries
sum = 0; Object.entries(results[0]).forEach(([k, v]) => sum += results[0][k]);
N: 10000 Object.entries
sum = 0; Object.entries(results[1]).forEach(([k, v]) => sum += results[1][k]);
N: 1000 For In
sum = 0; for (const k in results[0]) { sum += results[0][k] }
N: 10000 For In
sum = 0; for (const k in results[1]) { sum += results[1][k] }
N: 100000 Object.entries
sum = 0; Object.entries(results[2]).forEach(([k, v]) => sum += results[2][k]);
N: 100000 For In
sum = 0; for (const k in results[2]) { sum += results[2][k] }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
N: 1000 Object.entries
N: 10000 Object.entries
N: 1000 For In
N: 10000 For In
N: 100000 Object.entries
N: 100000 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 benchmark and its various aspects.

**Benchmark Overview**

The benchmark compares two approaches for iterating over an object in JavaScript:

1. `Object.entries()`
2. `for...in` loop

The goal is to determine which approach is faster for large objects.

**Options Compared**

* `Object.entries()`: Iterates over an object using its `entries()` method, which returns an array of key-value pairs.
* `for...in` loop: Uses a traditional loop to iterate over the object's properties (i.e., keys).

**Pros and Cons**

* **Object.entries()**
	+ Pros:
		- More concise and readable code
		- Works with objects that have inherited properties
	+ Cons:
		- May be slower due to the overhead of creating an array from the object's entries
* `for...in` loop`
	+ Pros:
		- Can be faster for small to medium-sized objects
		- More control over iteration and skipping properties
	+ Cons:
		- Less concise and readable code
		- May not work correctly with inherited properties

**Library Used**

None explicitly mentioned. However, the `Array` and `Math.random()` functions are used in the script preparation code.

**Special JS Feature/Syntax**

The benchmark uses the `let sum = 0;` syntax to initialize a variable and accumulate a sum over all iterations. This is a common pattern for simple benchmarks.

**Benchmark Preparation Code**

The script preparation code creates an array of object sizes (`ns`) and iterates over it using a `forEach()` loop, generating random key-value pairs for each object. The resulting objects are stored in the `results` array.

**Individual Test Cases**

Each test case has a specific object size (`N`) and uses either `Object.entries()` or `for...in` loop to iterate over an object in the `results` array. The accumulation of the sum is performed using the same syntax as before.

**Latest Benchmark Results**

The results show that:

* For small objects (1000), `Object.entries()` is faster.
* For medium-sized objects (10,000), `for...in` loop is faster.
* For large objects (100,000 and 1,000,000), `for...in` loop is significantly faster.

Keep in mind that these results may vary depending on the specific use case, object structure, and JavaScript engine used.

Latest run results:

Run details: (Test run date: 4 months ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Linux

View result in a separate tab

Test name	Executions per second
N: 1000 Object.entries	2310.4 Ops/sec
N: 10000 Object.entries	187.5 Ops/sec
N: 1000 For In	2796.6 Ops/sec
N: 10000 For In	242.2 Ops/sec
N: 100000 Object.entries	12.9 Ops/sec
N: 100000 For In	20.9 Ops/sec

Related benchmarks:

My: Object.entries vs For In (version: 0)

Comparing performance of: N: 1000 Object.entries vs N: 10000 Object.entries vs N: 1000 For In vs N: 10000 For In vs N: 100000 Object.entries vs N: 100000 For In

Created: 4 months ago by: Registered User

Jump to the latest result

N: 1000 Object.entries

N: 10000 Object.entries

N: 1000 For In

N: 10000 For In

N: 100000 Object.entries

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