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

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 = {}; Object.entries(window.parentObj).forEach(([k, v], i) => { if ((i % 2) === 0) { newObj[k] = v; } });
Object.keys
const newObj = {}; Object.keys(window.parentObj).forEach((k, i) => { if ((i % 2) === 0) { newObj[k] = window.parentObj[k]; } });
Object.keys with extra array
const newObj = {}; Object.keys(window.parentObj).forEach((k, i) => { const [extraK, v] = [k, window.parentObj[k]] if ((i % 2) === 0) { newObj[extraK] = v; } });
Object.entries without array
const newObj = {}; Object.entries(window.parentObj).forEach((keyAndVal, i) => { if ((i % 2) === 0) { newObj[keyAndVal[0]] = keyAndVal[1]; } });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.entries
Object.keys
Object.keys with extra array
Object.entries without array

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Overview**

The provided JSON represents a benchmarking test case, specifically designed to compare the performance of three different methods for iterating over objects: `Object.entries`, `Object.keys`, and their variations with an extra array.

**Methods being compared**

1. **`Object.entries`**: This method returns an array of two elements: the key-value pair as a string, in the format `[key, value]`. It's used to iterate over object properties.
2. **`Object.keys`**: This method returns an array of strings containing the keys of an object.
3. **`Object.keys with extra array`**: A variation of `Object.keys`, which takes two arguments: the object and an extra array.

**Options being compared**

The benchmark tests four different methods:

1. **`Object.entries` without array**: This is the original method, which returns an array of key-value pairs.
2. **`Object.keys` without array**: This method returns an array of keys only.
3. **`Object.entries with array` (not used in this test)**: Not applicable, as it's not part of the benchmark.
4. **`Object.keys with extra array`**: A variation that takes two arguments, which is not used in this specific test case.

**Pros and Cons**

Here are some pros and cons for each method:

1. **`Object.entries` without array**:
	* Pros: Simple and efficient, as it only iterates over the object's properties.
	* Cons: Requires a fixed-size array to store key-value pairs, which can lead to memory allocation overhead.
2. **`Object.keys` without array**:
	* Pros: Fast and lightweight, as it only returns an array of keys.
	* Cons: Can be slower for large objects due to the need to create multiple iterations over the object's properties.

3. **`Object.keys with extra array` (not used in this test)**:
	* Pros: Could potentially improve performance by reducing memory allocation overhead, as it only returns an array of keys.
	* Cons: Not applicable, as it's not part of the benchmark.

**Library usage**

The `window.parentObj` variable is a reference to an object created using the provided script preparation code. This object contains 100 properties with randomly generated keys and values.

**Special JS feature or syntax**

There are no special features or syntax used in this benchmark. It's purely a test of iteration methods.

**Other alternatives**

If you're interested in exploring alternative iteration methods, here are some additional options:

1. **Using `for...in`**: This method iterates over an object's properties using the `in` operator.
2. **Using `for...of`**: This method is a newer iteration technique introduced in ECMAScript 2015 (ES6), which allows iterating over iterable objects, including arrays and objects.

In conclusion, this benchmark provides valuable insights into the performance characteristics of different iteration methods for working with JavaScript objects.

Latest run results:

Run details: (Test run date: 21 hours ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Object.entries	77107.2 Ops/sec
Object.keys	85551.8 Ops/sec
Object.keys with extra array	52782.0 Ops/sec
Object.entries without array	78206.1 Ops/sec

Related benchmarks:

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

Comparing performance of: Object.entries vs Object.keys vs Object.keys with extra array vs Object.entries without array

Created: 6 years ago by: Guest

Jump to the latest result

Object.entries

Object.keys

Object.keys with extra array

Object.entries without array

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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