Benchmark: Object.values VS Object.entries VS Object.keys VS Object.keys VS Object.values with forEach

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).map(([k, v]) => { newObj[k] = v; });
Object.values
const newObj = {}; Object.values(window.parentObj).map((o, i) => { newObj[newObj[i]] = o; });
Object.keys
const newObj = {}; Object.keys(window.parentObj).map((k, i) => { newObj[k] = window.parentObj[k]; });
Object.values with forEach
const newObj = {}; Object.values(window.parentObj).forEach((o, i) => { newObj[newObj[i]] = o; });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.entries
Object.values
Object.keys
Object.values with forEach

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON and explain what's being tested, compared options, pros and cons of each approach, and other considerations.

**Benchmark Definition**

The benchmark is designed to compare the performance of four different ways to iterate over an object:

1. `Object.entries()`
2. `Object.values()`
3. `Object.keys()`
4. A combination of `Object.values()` and `forEach()`

**Options Compared**

* **`Object.entries()`**: Returns an array of a given object's key-value pairs, where each pair is an array with two elements: the key and the value.
* **`Object.values()`**: Returns an array of the values of an object.
* **`Object.keys()`**: Returns an array of the keys of an object.
* **Combination of `Object.values()` and `forEach()`**: Uses `map()` to iterate over the values of an object, which returns a new array with the results.

**Pros and Cons**

* **`Object.entries()`**:
	+ Pros: Can be used when you need both keys and values.
	+ Cons: May have higher overhead due to array creation and iteration.
* **`Object.values()`**:
	+ Pros: Faster than `Object.keys()` since it doesn't require creating an array of keys.
	+ Cons: Only returns the values, not the keys. May not be suitable when you need both.
* **`Object.keys()`**:
	+ Pros: Returns only the keys, which can be useful for certain use cases.
	+ Cons: Slower than `Object.values()` since it requires creating an array of keys.
* **Combination of `Object.values()` and `forEach()`**:
	+ Pros: Can avoid the overhead of creating arrays or iterating over key-value pairs.
	+ Cons: May have higher memory usage due to the creation of a new array.

**Library Usage**

None of the options require any external libraries, making them suitable for use in most JavaScript environments.

**Special JS Feature/Syntax**

* The benchmark uses `map()` and `forEach()` to iterate over arrays. While these methods are widely supported, some older browsers might not support `forEach()`.
* The benchmark also uses `const newObj = {}` to create a new object, which is a modern JavaScript feature (ECMAScript 2015+).

**Other Considerations**

* The benchmark creates a large object with 100 properties using a randomly generated key for each property. This ensures that the performance differences between the options are not due to small overheads.
* The benchmark runs on a desktop platform, which might affect the results compared to mobile or web platforms.

**Alternatives**

If you need to compare the performance of different ways to iterate over an object in JavaScript, these alternatives can be considered:

* Use a testing library like Jest or Mocha with built-in timing and execution statistics.
* Write a custom benchmarking script using a framework like Benchmark.js or jsperf.
* Utilize existing benchmarking tools and frameworks, such as Microbenchmark (a popular alternative to Benchmark.js).

Latest run results:

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

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

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
Object.entries	58569.4 Ops/sec
Object.values	90407.3 Ops/sec
Object.keys	47500.6 Ops/sec
Object.values with forEach	86573.2 Ops/sec

Related benchmarks:

Object.values VS Object.entries VS Object.keys VS Object.keys VS Object.values with forEach (version: 0)

Comparing performance of: Object.entries vs Object.values vs Object.keys vs Object.values with forEach

Created: one year ago by: Guest

Jump to the latest result

Object.entries

Object.values

Object.keys

Object.values with forEach

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