Benchmark: Object.keys vs Object.getOwnPropertyNames

Script Preparation code:

var obj = {
  a: 1,
  b: [2,3,4],
  c: "test",
  d: 1,
  e: 3,
  f: 21
}

Tests:

Object.keys
Object.keys(obj);
Object.getOwnPropertyNames
Object.getOwnPropertyNames(obj)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.keys
Object.getOwnPropertyNames

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; rv:104.0) Gecko/20100101 Firefox/104.0

Browser/OS: Firefox 104 on Windows

View result in a separate tab

Test name	Executions per second
Object.keys	10708776.0 Ops/sec
Object.getOwnPropertyNames	12534661.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The provided JSON represents a JavaScript microbenchmark on the website MeasureThat.net. The benchmark compares the performance of two methods for iterating over an object's properties: `Object.keys()` and `Object.getOwnPropertyNames()`. Let's break down what's being tested and what options are being compared.

**Options Compared**

1. **`Object.keys()`**: This method returns an array of a given object's own enumerable property names.
2. **`Object.getOwnPropertyNames()`**: This method returns an array of all properties (enumerable and non-enumerable) of a given object.

**Pros and Cons of Each Approach**

*   **`Object.keys()`**:
    *   Pros:
        *   Returns only enumerable property names, which can be beneficial for code readability and maintainability.
        *   More suitable for use cases where only enumerable properties are relevant.
    *   Cons:
        *   Can be slower than `Object.getOwnPropertyNames()` due to the filtering process.
*   **`Object.getOwnPropertyNames()`**:
    *   Pros:
        *   Returns all properties (enumerable and non-enumerable), which can be beneficial for certain use cases where non-enumerable properties are relevant.
        *   Can be faster than `Object.keys()` since it doesn't need to filter out non-enumerable properties.
    *   Cons:
        *   Returns non-enumerable properties, which might not be desirable in all situations.

**Library and Purpose**

There is no explicit library being used in this benchmark. The JavaScript built-in functions `Object.keys()` and `Object.getOwnPropertyNames()` are being utilized to compare their performance.

**Special JS Feature or Syntax**

The test doesn't use any special JavaScript features or syntax that would require additional explanation.

**Other Alternatives**

If you needed to iterate over an object's properties, other alternatives might include:

1.  **`for...in` loop**: This can be used with `Object.prototype.hasOwnProperty.call()` to ensure only enumerable properties are processed.
2.  **`Array.from()` and `Object.entries()`**: These can be used together to create an array of property names from an object, which can then be iterated over.

```javascript
for (const key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) {
        console.log(key);
    }
}
```

```javascript
console.log(Array.from(Object.entries(obj)).map(([key, value]) => key));
```

Keep in mind that each approach has its trade-offs and may be more suitable depending on your specific use case.

Related benchmarks:

Object.keys vs Object.getOwnPropertyNames (version: 0)

Comparing performance of: Object.keys vs Object.getOwnPropertyNames

Created: 3 years ago by: Registered User

Jump to the latest result

Object.keys

Object.getOwnPropertyNames

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