Benchmark: Object Values vs for .. in

Tests:

Object.values(obj)
var a = { a: 1, b: 2, c: 3}; var total = 0; Object.values(a).forEach(value => { total += value; }); total = total + 10;
for...in
var a = { a: 1, b: 2, c: 3}; var total = 0; for(var key in a) { total += a[key]; } total = total + 10;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.values(obj)
for...in

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.93 Safari/537.36

Browser/OS: Chrome 96 on Linux

View result in a separate tab

Test name	Executions per second
Object.values(obj)	2693393.2 Ops/sec
for...in	50785776.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested, compared, and the pros and cons of each approach.

**Benchmark Overview**

The benchmark compares two ways to iterate over an object in JavaScript:

1. `Object.values(obj)` (using the `Object.values()` method)
2. `for...in` loop (using a traditional loop to access object properties)

**Options Compared**

The benchmark is testing two options:

1. **`Object.values(obj)`**: This method was introduced in ECMAScript 2019 and provides a more modern, concise way to get an array of an object's property values.
2. **`for...in` loop**: This is a traditional, older approach to iterating over an object's properties.

**Pros and Cons**

### `Object.values(obj)`:

Pros:

* More concise and readable code
* Easier to maintain and modify
* Faster performance (as seen in the benchmark results)

Cons:

* Not supported in older browsers or versions of JavaScript (e.g., before ECMAScript 2019)
* May not work as expected with certain object types (e.g., objects with inherited properties)

### `for...in` loop:

Pros:

* Wide browser support and compatibility
* Works with any object type, including those with inherited properties

Cons:

* More verbose and less readable code
* Can be slower than the `Object.values()` method due to additional overhead

**Other Considerations**

* The benchmark uses Chrome 96 as the test environment, which supports both options.
* The test cases are simple and focus on iterating over a small object with three properties (a, b, c). In real-world scenarios, the performance difference between these options might be more noticeable when dealing with larger objects or more complex logic.
* It's worth noting that the `Object.values()` method may not always be the best choice, depending on the specific use case. For example, if you need to iterate over an object's own properties (excluding inherited ones), `for...in` might be a better option.

**Other Alternatives**

If you're looking for alternative ways to iterate over objects in JavaScript, you could consider:

* **`Object.keys()`**: Returns an array of an object's property names. Can be used with a traditional loop or the `Array.prototype.forEach()` method.
* **`for...of` loop**: Similar to the `for...in` loop but iterates over an object's own enumerable properties (excluding inherited ones).
* **`Symbol.iterator` and `for...of` loop**: Another approach to iterating over objects, which allows for more fine-grained control over iteration logic.

Keep in mind that each of these alternatives has its pros and cons, and the choice ultimately depends on your specific use case and performance requirements.

Related benchmarks:

Object Values vs for .. in (version: 0)

Comparing performance of: Object.values(obj) vs for...in

Created: 2 years ago by: Guest

Jump to the latest result

Object.values(obj)

for...in

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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