Benchmark: Object.keys vs for in vs Object.getOwnPropertyNames with a twist

Script Preparation code:

var obj = {
  $props : ['a','b','c'],
  a:1,
  b:2,
  c:3
}

Tests:

asta castiga btw
let n = 0; for (let k in obj) { n++; }
meh
const arr = Object.keys(obj); let n = 0; for (let i in arr) { n++; }
meh 2
const arr = Object.getOwnPropertyNames(obj); let n = 0; for (let i = 0; i < arr.length; i++) { n++; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
asta castiga btw
meh
meh 2

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 benchmark and its test cases.

**Benchmark Definition**

The benchmark measures the performance of three approaches to iterate over an object's properties:

1. `for...in` loop
2. `Object.keys()` method
3. `Object.getOwnPropertyNames()` method

The twist is that the object contains a property `$props` which is an array, and other properties with numeric values.

**Options Compared**

Here are the three options being compared:

1. **For-in Loop**: Iterates over the object's own enumerable properties using the `for...in` loop syntax.
2. **Object.keys() Method**: Returns an array of a given object's own enumerable property names.
3. **Object.getOwnPropertyNames() Method**: Returns an array of all the own property (including non-enumerable) names of a given object.

**Pros and Cons**

* **For-in Loop**: Pros: easy to read and write, can handle non-enumerable properties. Cons: may include non-enumerable properties in iteration, performance can be slower due to the loop's nature.
* **Object.keys() Method**: Pros: efficient and concise way to iterate over enumerable properties, excludes non-enumerable properties. Cons: may have a slight performance overhead due to the method call, and may not work on older browsers.
* **Object.getOwnPropertyNames() Method**: Pros: includes all own properties (including non-enumerable), can be used for specific use cases where iteration needs to include non-enumerable properties. Cons: less efficient than `Object.keys()` method due to including non-enumerable properties, may have a slight performance overhead.

**Library and Special JS Features**

* **$props**: This is not a built-in JavaScript library, but rather a custom property defined in the benchmark script preparation code. It's an array containing strings 'a', 'b', and 'c'.
* No special JavaScript features are used in this benchmark.

**Other Considerations**

The benchmark measures the performance of these three approaches under different conditions (e.g., iteration over different types of properties). The results can help developers understand which approach is most efficient for specific use cases.

**Alternatives**

Some alternative approaches to iterating over an object's properties include:

* Using `for...in` loop with the `[Symbol.iterator]()` method, which allows iterating over non-enumerable properties.
* Using a library like Lodash or Underscore.js, which provide more efficient and concise ways to iterate over objects.

However, in this specific benchmark, the three options being compared are the primary focus.

Latest run results:

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

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

Browser/OS: Chrome 74 on Mac OS X 10.14.4

View result in a separate tab

Test name	Executions per second
asta castiga btw	13385419.0 Ops/sec
meh	2155420.5 Ops/sec
meh 2	4686209.0 Ops/sec

Related benchmarks:

Object.keys vs for in vs Object.getOwnPropertyNames with a twist (version: 0)

?

Comparing performance of: asta castiga btw vs meh vs meh 2

Created: 5 years ago by: Guest

Jump to the latest result

asta castiga btw

meh

meh 2

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