Benchmark: ok5}O.54<'fn9ZN2KFz=

Tests:

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

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: one year ago)

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

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

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

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and its details.

**Benchmark Overview**

The provided benchmark is comparing two ways to iterate over an object in JavaScript: `Object.values()` and `for...in`. The goal is to measure which approach is faster.

**Options Compared**

Two options are compared:

1. **`Object.values(obj)`**: This method returns an array of a given object's own enumerable property values.
2. **`for...in` loop with `key in obj`**: This traditional loop iterates over the object's properties using a `for` loop and checks if each property is enumerable.

**Pros and Cons**

**`Object.values(obj)`**

Pros:

* More modern, concise way to iterate over an object.
* No need for explicit looping or checking properties.
* Works with non-enumerable properties (using `Object.keys()` would).

Cons:

* May not work as expected if the object's properties are not enumerable (e.g., using `for...in`).
* Requires modern JavaScript versions.

**`for...in` loop**

Pros:

* Widely supported, works across all browsers and versions.
* Can iterate over both enumerable and non-enumerable properties.

Cons:

* More verbose and less readable than `Object.values()`.
* May be slower due to the extra overhead of checking property existence.

**Library Used**

None explicitly mentioned in the provided code. However, it's worth noting that `Object.values()` is a part of the ECMAScript Standard Library, while `for...in` is a built-in JavaScript construct.

**Special JS Feature or Syntax (Not Mentioned)**

No special features or syntax are used in this benchmark. Both options rely on standard JavaScript constructs and libraries.

**Other Alternatives**

Alternative ways to iterate over an object include:

* Using `Array.prototype.forEach()`: This method can be more concise, but it's less readable than using a traditional loop.
* Using `for...of` loop with `Object.entries()` or `Object.keys()`: These methods provide more flexibility and readability.

However, in the context of this benchmark, `Object.values(obj)` is likely the preferred choice for its conciseness and modernity.

Related benchmarks:

ok5}O.54<'fn9ZN2KFz= (version: 0)

asd

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

Created: one year 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):