Benchmark: foreach: object keys vs object values vs object entries

Script Preparation code:

var obj = {};

for (i = 0; i < 1000; ++i) {
  obj[i] = i;
}

Tests:

object with keys
Object.keys(obj).forEach( (key) => key, );
object with values
Object.values(obj).forEach( (value) => value, );
object with entries 1
Object.entries(obj).forEach( (entry) => entry, );
object with entries 2
Object.entries(obj).forEach( ([key, value]) => [key, value], );

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
object with keys
object with values
object with entries 1
object with entries 2

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 9 days ago)

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

Browser/OS: Chrome 147 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
object with keys	170366.8 Ops/sec
object with values	569170.7 Ops/sec
object with entries 1	49461.2 Ops/sec
object with entries 2	48253.7 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll provide an explanation of the benchmark and its test cases.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark created on MeasureThat.net. The benchmark compares the performance of three different approaches to iterate over object keys, values, or entries using the `forEach` method.

**Options Compared**

There are four test cases:

1. **Object.keys(obj).forEach((key) => key)**: This approach uses the `keys()` method to get an array of a given object's own enumerable property names and then iterates over this array using `forEach`.
2. **Object.values(obj).forEach((value) => value)**: This approach uses the `values()` method to get an array of a given object's own enumerable property values and then iterates over this array using `forEach`.
3. **Object.entries(obj).forEach((entry) => entry)**: This approach uses the `entries()` method to get an array of a given object's own enumerable key-value pairs and then iterates over this array using `forEach`.
4. **Object.entries(obj).forEach(([key, value]) => [key, value])**: This approach is similar to the previous one but uses destructuring assignment (`[key, value]`) to extract the key-value pair from each entry.

**Pros and Cons of Each Approach**

1. **Object.keys(obj).forEach((key) => key)**:
	* Pros: Simple and easy to understand.
	* Cons: May require additional memory allocation for the `keys()` method array.
2. **Object.values(obj).forEach((value) => value)**:
	* Pros: Can be faster than using keys because it doesn't require iterating over an array of names.
	* Cons: May not work correctly if the object has inherited properties or if property names are not unique.
3. **Object.entries(obj).forEach((entry) => entry)**:
	* Pros: Efficient use of memory and can be faster than using `keys()` or `values()`.
	* Cons: Requires understanding of key-value pair iteration, which may be unfamiliar to some developers.
4. **Object.entries(obj).forEach(([key, value]) => [key, value])**:
	* Pros: Similar benefits to the previous approach but with a more concise syntax.
	* Cons: May still require additional memory allocation for the `entries()` method array.

**Other Considerations**

* The benchmark assumes that the object being iterated over is relatively small (1000 properties) and has no complex relationships between its properties. In real-world scenarios, these assumptions may not always hold true.
* The benchmark does not consider other factors that can impact performance, such as the specific JavaScript engine or runtime environment used.

**Libraries Used**

None of the provided test cases use any external libraries. They rely solely on built-in JavaScript methods and syntax.

**Special JS Features/Syntax**

There are no special JavaScript features or syntax mentioned in the benchmark. All tests are written using standard JavaScript syntax.

I hope this explanation helps you understand the benchmark and its test cases!

Related benchmarks:

foreach: object keys vs object values vs object entries (version: 0)

Comparing performance of: object with keys vs object with values vs object with entries 1 vs object with entries 2

Created: 3 years ago by: Guest

Jump to the latest result

object with keys

object with values

object with entries 1

object with entries 2

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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