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

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]; } });
Object.values
const newObj = {}; Object.values(window.parentObj).forEach((v, i) => { if ((i % 2) === 0) { newObj[i] = v; } });

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
Object.values

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The provided JSON represents a benchmarking test created on MeasureThat.net, which compares the performance of different approaches to iterate over an object's entries and values in JavaScript.

**Benchmark Definition:**

The test has four test cases:

1. `Object.entries`: Iterates over an object's key-value pairs using the `Object.entries()` method.
2. `Object.keys`: Iterates over an object's keys using the `Object.keys()` method.
3. `Object.keys with extra array`: Iterates over an object's keys, but also includes a separate array of values (`extraArray`) to access each value by index.
4. `Object.entries without array`: Similar to `Object.entries`, but omits the use of an array for accessing values.

**Comparison:**

The test compares the performance of these four approaches in terms of the number of executions per second (ExecutionsPerSecond).

**Options Compared:**

* Using `Object.entries()` vs. using `Object.keys()` vs. using `Object.keys() + extraArray` vs. using `Object.entries()` without an array.
* Performance differences between iterating over key-value pairs directly (`Object.entries()`) and iterating over keys alone (`Object.keys()`).

**Pros and Cons:**

1. **Using `Object.entries()`**: Pros:
	* Native method, optimized for performance.
	* Allows direct access to both keys and values.
Cons:
	* May incur additional overhead due to the array-like object returned by `Object.entries()`.
2. **Using `Object.keys()`**: Pros:
	* Fast and efficient, as it only iterates over keys.
Cons:
	* No direct access to values; must use another method (e.g., `Object.values()` or indexing).
3. **Using `Object.keys with extraArray`**: This approach is not recommended, as it introduces unnecessary complexity and potential overhead due to the separate array of values.

**Other Considerations:**

* The test does not consider edge cases, such as empty objects or objects with only one key-value pair.
* The use of a random ID generator (`makeid()`) in the benchmark preparation code ensures that the test results are consistent across different runs.

**Alternative Approaches:**

1. **Using `Object.values()`**: Iterates over an object's values directly, which may be more efficient than using `Object.keys()` and then accessing each value separately.
2. **Custom iteration**: Implementing a custom iteration loop to access keys and values in a specific order or structure.

Keep in mind that the performance differences between these approaches can depend on various factors, such as the size of the input object, the type of data stored in the object, and the specific JavaScript engine used.

Latest run results:

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

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

Browser/OS: Opera 111 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.entries	67885.0 Ops/sec
Object.keys	81544.0 Ops/sec
Object.keys with extra array	49227.6 Ops/sec
Object.entries without array	69963.5 Ops/sec
Object.values	96041.1 Ops/sec

Related benchmarks:

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

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

Created: 4 months ago by: Guest

Jump to the latest result

Object.entries

Object.keys

Object.keys with extra array

Object.entries without array

Object.values

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