Benchmark: Object.entries VS Object.keys VS Object.keys with extra array VS Object.entries without array 103

Script Preparation code:

function makeid() {
  var text = "";
  var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

  for (var i = 0; i < 5; i++)
    text += possible.charAt(Math.floor(Math.random() * possible.length));

  return text;
}

window.parentObj = {};

for (let i = 0; i < 100; i++) {
	window.parentObj[makeid()] = makeid();
}

Tests:

Object.entries
const newObj = {}; const parentObj = window.parentObj; Object.entries(parentObj).forEach(([k, v], i) => { newObj[k] = v; });
Object.keys
const newObj = {}; const parentObj = window.parentObj; Object.keys(parentObj).forEach((k, i) => { newObj[k] = parentObj[k]; });
Object.entries without array
const newObj = {}; Object.entries(window.parentObj).forEach((keyAndVal, i) => { newObj[keyAndVal[0]] = keyAndVal[1]; });
For in
const newObj = {}; const parentObj = window.parentObj; for (let key in parentObj) { newObj[key] = parentObj[key]; }
For of keys
const newObj = {}; const parentObj = window.parentObj; for (let key of Object.keys(parentObj)) { newObj[key] = parentObj[key]; }
For of entries
const newObj = {}; const parentObj = window.parentObj; for (let kv of Object.entries(parentObj)) { newObj[kv[0]] = kv[1]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.entries
Object.keys
Object.entries without array
For in
For of keys
For of entries

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:128.0) Gecko/20100101 Firefox/128.0

Browser/OS: Firefox 128 on Windows

View result in a separate tab

Test name	Executions per second
Object.entries	487343.2 Ops/sec
Object.keys	820517.3 Ops/sec
Object.entries without array	512904.2 Ops/sec
For in	1445939.8 Ops/sec
For of keys	834820.0 Ops/sec
For of entries	439762.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance can be complex, so I'll break down each test case.

**Benchmark Definition**

The benchmark compares the performance of different methods to iterate over an object's keys:

1. `Object.entries`
2. `Object.keys`
3. `For in` (using `for...in`)
4. `For of keys` (using `for...of` on the result of `Object.keys`)
5. `For of entries` (using `for...of` on the result of `Object.entries`, without an array)

**Options Compared**

Each test case measures the performance of a specific method to iterate over the object's keys, with some variations:

* Some methods use an array as an intermediate step (`Object.keys` and `For in`)
* Others use `for...of` directly on the result of `Object.entries` or `Object.keys` (`For of entries` and `For of keys`, respectively)
* The `Object.entries` method is tested with and without using an array.

**Pros and Cons**

Here's a brief summary of each approach:

1. **`Object.entries`**: Pros: concise, flexible, and modern. Cons: may be slower due to the extra step of iterating over the array.
2. **`Object.keys`**: Pros: simple, fast, and widely supported. Cons: requires an explicit loop or `for...of` on the result.
3. **`For in`**: Pros: simple and old-school. Cons: may be slower due to the extra step of checking object properties using bracket notation.
4. **`For of keys`**: Pros: concise, readable, and modern. Cons: requires `Object.keys` as an intermediate step.
5. **`For of entries`**: Pros: flexible, modern, and concise. Cons: requires `Object.entries` as an intermediate step.

**Library and Purpose**

The `window.parentObj` object is used to simulate a nested object structure. Its purpose is to create a scenario where the benchmark methods need to access its properties recursively.

**Special JS Feature or Syntax**

None of the test cases use any special JavaScript features or syntax, apart from using modern syntax like `for...of`.

**Other Alternatives**

Other alternatives for iterating over an object's keys could include:

* Using `JSON.parse(JSON.stringify(obj))` (although this is not recommended due to its performance and security implications)
* Using a custom iterator function
* Using a third-party library like Lodash

It's worth noting that the `Object.keys()` method is often considered the most performant way to iterate over an object's keys, especially when using modern browsers. However, the benchmark results may vary depending on the specific use case and implementation details.

Related benchmarks:

Object.entries VS Object.keys VS Object.keys with extra array VS Object.entries without array 103 (version: 0)

Comparing performance of: Object.entries vs Object.keys vs Object.entries without array vs For in vs For of keys vs For of entries

Created: one year ago by: Guest

Jump to the latest result

Object.entries

Object.keys

Object.entries without array

For in

For of keys

For of entries

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