Benchmark: Consume Object.entries vs Object.keys vs for..in vs for..of

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 entries = Object.entries(obj), i = entries.length; --i >= 0;) { const [key] = entries[i] window.a = [key, obj[key]] }
for..in
for (const key in obj) { window.a = [key, obj[key]] }
Object.keys for
for (let keyArray = Object.keys(obj), i = keyArray.length, key = keyArray[--i]; i >= 0; key = keyArray[--i]) { window.a = [key, obj[key]] }
Object.keys for..of
for (const key of Object.keys(obj)) { window.a = [key, obj[key]] }
Object.entries for..of
for (const [key] of Object.entries(obj)) { window.a = [key, obj[key]] }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.entries
for..in
Object.keys for
Object.keys for..of
Object.entries for..of

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/135.0.0.0 Safari/537.36

Browser/OS: Chrome 135 on Windows

View result in a separate tab

Test name	Executions per second
Object.entries	3574019.8 Ops/sec
for..in	5280320.0 Ops/sec
Object.keys for	5385571.5 Ops/sec
Object.keys for..of	6856946.5 Ops/sec
Object.entries for..of	3530372.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript microbenchmarking test case, specifically comparing the performance of four different methods to iterate over an object's properties: `Object.entries`, `for..in`, `Object.keys for`, and `Object.keys for..of`. The test also measures the performance of using destructuring assignment (`const [key] = entries[i]`) with `Object.entries`.

**Options being compared:**

1. **`Object.entries`**: This method returns an array of arrays, where each inner array contains a key-value pair from the object.
2. **`for..in`**: This traditional loop iterates over the object's property names using the `in` operator.
3. **`Object.keys for`**: This method uses a `for...of` loop to iterate over an array of strings representing the object's property names, obtained by calling `Object.keys(obj)`.
4. **`Object.keys for..of`**: Similar to `Object.keys for`, but uses a `for...of` loop directly on the result of `Object.keys(obj)`.
5. **Destructuring assignment with `Object.entries` (`const [key] = entries[i]`)**

**Pros and Cons:**

1. **`Object.entries`**:
	* Pros: Can handle nested objects, uses destructuring assignment for key-value pairs.
	* Cons: Returns an array of arrays, which can be less efficient than iterating over individual property names.
2. **`for..in`**:
	* Pros: Widely supported and well-established method.
	* Cons: May not work as expected with objects that have inherited properties, or when using modern ECMAScript features like getters/setters.
3. **`Object.keys for`**:
	* Pros: Returns an array of strings representing property names only, reducing overhead.
	* Cons: Requires two separate calls (to get the array of property names and then iterate over it).
4. **`Object.keys for..of`**:
	* Pros: Combines the benefits of `Object.keys for`, with the simplicity of a single loop.
	* Cons: May be slightly slower due to the additional overhead of parsing the array.
5. **Destructuring assignment with `Object.entries` (`const [key] = entries[i]`)**:
	* Pros: Allows for concise and expressive code, leveraging modern ECMAScript features.
	* Cons: Can introduce additional overhead due to the creation of temporary arrays.

**Other considerations:**

When choosing an iteration method, consider the specific requirements of your application:

* If you need to iterate over both property names and values, `Object.entries` might be a good choice, despite its potential performance implications.
* If you're working with objects that have inherited properties or complex inheritance hierarchies, `for..in` may be a safer bet.
* If you can optimize for readability and conciseness, the destructuring assignment method (`const [key] = entries[i]`) might be preferred.

**Alternatives:**

For this specific benchmarking scenario, other alternatives to consider:

1. **Use a more modern ECMAScript feature:** If possible, consider using newer features like `for...of` loops with iterators or the `map()` method to iterate over objects.
2. **Consider caching results:** If the benchmark is used repeatedly for the same input data, caching intermediate results can help reduce overhead and improve performance.
3. **Use a different testing framework:** Depending on your specific use case and requirements, exploring alternative microbenchmarking frameworks or libraries might provide more suitable options.

Keep in mind that the choice of iteration method ultimately depends on your project's specific needs and constraints.

Related benchmarks:

Consume Object.entries vs Object.keys vs for..in vs for..of (version: 0)

Comparing performance of: Object.entries vs for..in vs Object.keys for vs Object.keys for..of vs Object.entries for..of

Created: 3 years ago by: Registered User

Jump to the latest result

Object.entries

for..in

Object.keys for

Object.keys for..of

Object.entries for..of

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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