Benchmark: Object.values, For...in, Object.keys Object.entires

Script Preparation code:

var a = { a: 1, b:2, c:3, d:4, e: 5, f: 6 }

Tests:

For ... in length test
let sum = 0; for (var x in a ) { sum++; }
Object.keys length test
Object.keys(a).length
Object.values length test
Object.values(a).length
Object.entries length test
Object.entries(a).length
For In Reduce test
let sum = 0; for (var x in a ) { sum += a[x] }
Object.keys Reduce test
Object.keys(a).reduce((prev, curr) => { var sum = prev + a[curr]; return sum; }, 0)
Object.values Reduce test
Object.values(a).reduce((prev, curr) => { return prev + curr; }, 0);
Object.entries reduce test
Object.entries(a).reduce((prev, curr) => { return prev + curr[1] }, 0)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For ... in length test
Object.keys length test
Object.values length test
Object.entries length test
For In Reduce test
Object.keys Reduce test
Object.values Reduce test
Object.entries reduce test

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what is tested on MeasureThat.net.

**Benchmark Definition**

The benchmark definition describes four ways to access and manipulate object properties in JavaScript:

1. `Object.keys(a).length`: This method returns an array of strings representing the property names of the object `a`.
2. `Object.values(a).length`: This method returns an array of values of the object `a` without their keys.
3. `for (var x in a) { ... }`: This is a traditional loop that iterates over the properties of the object `a`. The variable `x` takes on the value of each property name, and you can access the corresponding value using `a[x]`.
4. `Object.entries(a).length`: This method returns an array of tuples, where each tuple contains a key-value pair from the object `a`.

**Options being compared**

The benchmark is comparing the performance of these four approaches in terms of:

* Time taken to execute each test
* Number of executions per second (executionsPerSecond)

**Pros and Cons of each approach**

1. **`Object.keys(a).length`**: This method is simple and easy to read, but it may not be the most efficient way to access property names, especially if the object has many properties.
2. **`for (var x in a) { ... }`**: This traditional loop is still widely used, but it can be slower than modern methods like `Object.keys()` or `Object.values()`.
3. **`Object.values(a).length`**: This method returns an array of values without keys, which might make it faster than accessing each property individually.
4. **`Object.entries(a).length`**: This method returns an array of tuples containing key-value pairs, which could potentially be slower due to the overhead of creating and manipulating these tuples.

**Other considerations**

* The benchmark does not consider other factors that might affect performance, such as:
	+ Object size and complexity
	+ Property names and values (e.g., string literals vs. numbers)
	+ Browser and JavaScript engine specifics
	+ Test environment conditions (e.g., CPU usage, memory constraints)

**Libraries and special JS features**

None of the test cases explicitly use a library or special JS feature.

**Alternatives**

Other alternatives to these four approaches include:

* Using `Array.prototype.forEach()` instead of `for...in`
* Using `Object.getOwnPropertyNames()` instead of `Object.keys()`
* Using `Object.keys()` and then using `map()` or `reduce()` to process the results
* Using other libraries like Lodash (if you need more complex manipulations)

Keep in mind that performance differences between these approaches can be subtle, and the best choice depends on your specific use case and requirements.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/116.0

Browser/OS: Firefox 116 on Ubuntu

View result in a separate tab

Test name	Executions per second
For ... in length test	33667016.0 Ops/sec
Object.keys length test	22010310.0 Ops/sec
Object.values length test	15438587.0 Ops/sec
Object.entries length test	6265567.5 Ops/sec
For In Reduce test	17620388.0 Ops/sec
Object.keys Reduce test	9600209.0 Ops/sec
Object.values Reduce test	9906636.0 Ops/sec
Object.entries reduce test	4823545.5 Ops/sec

Related benchmarks:

Object.values, For...in, Object.keys Object.entires (version: 0)

Comparing performance of: For ... in length test vs Object.keys length test vs Object.values length test vs Object.entries length test vs For In Reduce test vs Object.keys Reduce test vs Object.values Reduce test vs Object.entries reduce test

Created: 3 years ago by: Guest

Jump to the latest result

For ... in length test

Object.keys length test

Object.values length test

Object.entries length test

For In Reduce test

Object.keys Reduce test

Object.values Reduce test

Object.entries reduce test

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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