Benchmark: hasOwnProperty vs NO-hasOwnProperty vs object.keys 2

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

let obj = {
  'a': 1,
  'b': 1,
  'c': 1,
  'd': 1,
  'e': 1,
  'f': 1,
  'g': 1
};

Tests:

hasOwnProperty
let data = []; for (let key in obj) { if(obj.hasOwnProperty(key)) { data.push(key); } }
NO-hasOwnProperty
let data = []; for (let key in obj) { data.push(key); }
Object.keys
let data = Object.keys(obj);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
hasOwnProperty
NO-hasOwnProperty
Object.keys

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 18 on iOS 18.2.1

View result in a separate tab

Test name	Executions per second
hasOwnProperty	35572076.0 Ops/sec
NO-hasOwnProperty	37762124.0 Ops/sec
Object.keys	441759424.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

The benchmark presented compares three different approaches for enumerating the keys of a JavaScript object: using `hasOwnProperty`, a direct enumeration without property checks, and the `Object.keys()` method. The benchmark aims to analyze which of these methods performs better in terms of execution speed.

### Approaches Compared

1. **Using `hasOwnProperty`**:
   - **Code**: 
     ```javascript
     let data = [];
     for (let key in obj) {
       if(obj.hasOwnProperty(key)) {
         data.push(key);
       }
     }
     ```
   - **Description**: This method iterates over the object's keys and checks if each key is a direct property of the object (not inherited from its prototype) by using `hasOwnProperty`. If it is, the key is pushed into an array.
   - **Pros**:
     - Safe against prototype pollution; only retrieves keys that are part of the object.
   - **Cons**:
     - This approach is slower because it requires an additional function call to `hasOwnProperty` for each key in the object.
  
2. **Direct Enumeration without `hasOwnProperty`**:
   - **Code**: 
     ```javascript
     let data = [];
     for (let key in obj) {
       data.push(key);
     }
     ```
   - **Description**: This method iterates over the keys of the object without checking if they are direct properties. It simply pushes all keys into the array.
   - **Pros**:
     - Faster execution than the `hasOwnProperty` variant as it does not involve additional function calls.
   - **Cons**:
     - It can include properties that are inherited from the prototype chain, potentially resulting in unexpected behavior if properties are added or overwritten.

3. **Using `Object.keys()`**:
   - **Code**: 
     ```javascript
     let data = Object.keys(obj);
     ```
   - **Description**: This method returns an array of a given object's own enumerable property names (key values), effectively retrieving the same result as the previous methods but optimized.
   - **Pros**:
     - Fastest of the three methods, and it automatically filters out inherited properties.
     - Clear and concise syntax, improving code readability.
   - **Cons**:
     - None significant for typical use cases, but it’s crucial to note that it does not return non-enumerable properties.

### Benchmark Results Summary

- **`Object.keys()`** achieved **45,032,416** executions per second, making it the fastest method.
- **Direct Enumeration (NO-hasOwnProperty)** resulted in **23,169,376** executions per second, which is noticeably faster than `hasOwnProperty` but slower than `Object.keys()`.
- **Using `hasOwnProperty`** had the lowest performance with **8,428,886** executions per second due to the additional function call for each key.

### Other Considerations

- **Performance**: The choice of method can significantly impact performance, especially when dealing with large objects or executing the operation multiple times.
- **Code Clarity**: The use of `Object.keys()` provides a clearer and more declarative way to achieve the intended result.
- **Compatibility with Prototypes**: Depending on the application, it might be crucial to consider whether inherited properties need to be included. Generally, using `Object.keys()` or checking with `hasOwnProperty()` is essential for avoiding unintended results.

### Alternatives

Additional alternatives for key enumeration in JavaScript include:
- **`Object.entries(obj)`**: Returns an array of the object's own enumerable string-keyed property [key, value] pairs, useful if both keys and values are needed.
- **`Object.values(obj)`**: Returns an array of the object's own enumerable property values, focusing only on the values while ignoring keys.
- **`forEach` with `Object.keys()`**: Combining the iteration with the usage of `Object.keys()` into a functional pattern could be an alternative for developers favoring functional programming paradigms.

Overall, for most scenarios, `Object.keys()` is recommended for its performance and safety regarding prototype pollution, aligning well with JavaScript's object handling best practices.

Related benchmarks:

hasOwnProperty vs NO-hasOwnProperty vs object.keys 2 (version: 1)

Comparing performance of: hasOwnProperty vs NO-hasOwnProperty vs Object.keys

Created: 3 months ago by: Guest

Jump to the latest result

hasOwnProperty

NO-hasOwnProperty

Object.keys

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):