Benchmark: Consume Object.entries vs for..in vs for..in fn 22222

Script Preparation code:

var obj = {
	a: 1,
    b: 2,
	c: 3,
	d: 4,
	0: 'a',
  	1: 'b',
  	str: 'long string',
	nested: {
    	nested: 0
    },
	hello: 55.5
};

Tests:

Object.entries
for (let i = 0; i < 10000; i++) { for (let entries = Object.entries(obj), i = entries.length - 1; i >= 0; i--) { console.log(entries[i]) } }
for..in
for (let i = 0; i < 10000; i++) { for (let key in obj) { if (obj.hasOwnProperty(key)) { console.log([key, obj[key]]) } } }
Object.keys
for (let i = 0; i < 10000; i++) { for (let keyArray = Object.keys(obj), i = keyArray.length - 1, key = keyArray[i]; i >= 0; key = keyArray[--i]) { console.log([key, obj[key]]); } }
Object.keys no entry
for (let i = 0; i < 10000; i++) { for (let keyArray = Object.keys(obj), i = keyArray.length - 1, key = keyArray[i]; i >= 0; key = keyArray[--i]) { console.log(key, obj[key]); } }
for..in no array
for (let i = 0; i < 10000; i++) { for (let key in obj) { if (obj.hasOwnProperty(key)) { console.log(key, obj[key]) } } }
Object.entries no array
for (let i = 0; i < 10000; i++) { for (let entries = Object.entries(obj), i = entries.length - 1, entry = entries[i]; i >= 0; entry = entries[i--]) { console.log(entry[0], entry[1]) } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.entries
for..in
Object.keys
Object.keys no entry
for..in no array
Object.entries no array

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The benchmark in question compares the performance of four different approaches: `Object.entries`, `for..in`, `Object.keys`, and variations of these two.

**What is tested?**

The benchmark tests the performance of each approach in iterating over an object's keys and values. Specifically:

* `Object.entries` returns an array of key-value pairs.
* `for..in` iterates over the object's property names (including those with non-standard names).
* `Object.keys` returns an array of property names.

The benchmark uses a single object, `obj`, with 10 properties: `a`, `b`, `c`, `d`, `0`, `1`, `str`, `nested`, and `hello`.

**Options compared**

The benchmark compares the following options:

* **`Object.entries`**: Returns an array of key-value pairs.
	+ Pros: Efficient and easy to use. Returns all properties, including those with non-standard names.
	+ Cons: May be slower than other approaches for very large objects.
* **`for..in`**: Iterates over the object's property names.
	+ Pros: Fast and efficient for iterating over property names. Includes properties with non-standard names.
	+ Cons: Can iterate over own enumerable property names, including those that might not be what you expect (e.g., `__proto__`).
* **`Object.keys`**: Returns an array of property names.
	+ Pros: Efficient and easy to use. Excludes properties with non-standard names.
	+ Cons: May not include all properties if they are non-enumerable or hidden.

**Variations**

The benchmark also tests variations of `for..in`:

* **`Object.entries no array`**: Returns an array of key-value pairs instead of property names.
	+ Pros: Efficient and easy to use. Includes properties with non-standard names.
	+ Cons: Not suitable for iterating over property names only.
* **`for..in no array`**: Iterates over the object's property names without returning any values.
	+ Pros: Fast and efficient for iterating over property names. Excludes properties with non-standard names.
	+ Cons: Does not return any values, so cannot be used for testing purpose.

**Performance**

The benchmark runs each option on multiple browsers and devices, measuring the time it takes to execute a loop that iterates over the object's keys and values using each approach.

**Conclusion**

In general, `Object.entries` is the fastest option when iterating over an object's key-value pairs. However, if you only need to iterate over property names, `for..in` or `Object.keys` might be faster due to their more efficient iteration mechanisms.

Keep in mind that this benchmark only tests a specific use case and may not represent all scenarios. Additionally, the results may vary depending on the specific object, browser, and device being used.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.entries	6.7 Ops/sec
for..in	5.5 Ops/sec
Object.keys	5.8 Ops/sec
Object.keys no entry	5.7 Ops/sec
for..in no array	5.2 Ops/sec
Object.entries no array	6.3 Ops/sec

Related benchmarks:

Consume Object.entries vs for..in vs for..in fn 22222 (version: 0)

Comparing performance of: Object.entries vs for..in vs Object.keys vs Object.keys no entry vs for..in no array vs Object.entries no array

Created: 4 years ago by: Guest

Jump to the latest result

Object.entries

for..in

Object.keys

Object.keys no entry

for..in no array

Object.entries no array

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