Benchmark: Object lookup perf undefined vs. typeof vs. in vs. hasOwnProperty

Script Preparation code:

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

Tests:

undefined
undefined === obj.f;
typeof
'undefined' === typeof obj.d;
in
'f' in obj;
hasOwnProperty
obj.hasOwnProperty( 'f' );

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
undefined
typeof
in
hasOwnProperty

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring performance of object lookup methods is crucial in JavaScript, as it affects the overall efficiency and scalability of applications.

The provided benchmark compares four common methods for checking if a property exists in an object:

1.  **`undefined === obj.f`**: This method checks if `obj.f` is explicitly set to `undefined`.
2.  **`'undefined' === typeof obj.d`**: This method uses the `typeof` operator to check if `obj.d` is of type "undefined".
3.  **`'f' in obj`**: This method uses the `in` operator to check if `'f'` is a property of `obj`.
4.  **`obj.hasOwnProperty('f')`**: This method checks if `obj` has a property called `'f'`.

**Options Comparison:**

*   **`undefined === obj.f`**: This approach is the fastest among all four, as it directly compares the value of `obj.f` with `undefined`. It's also the most straightforward way to check for an undefined value.
    *   **Pros:** Fastest and most direct way to check for undefined values.
    *   **Cons:** May not work correctly if `obj.f` is set to a different type (e.g., null, 0, etc.) that can be falsy in a comparison.
*   **`'undefined' === typeof obj.d`**: This approach uses the `typeof` operator, which returns a string describing the type of `obj.d`. Comparing this string with `'undefined'` allows for correct checks even if `obj.d` is set to null or 0.
    *   **Pros:** Correctly handles cases where `obj.d` is not explicitly set to undefined, but can be falsy in a comparison.
    *   **Cons:** Slower than direct comparisons due to the overhead of string comparison and type checking.
*   **`'f' in obj`**: This approach uses the `in` operator, which checks if `'f'` is a property of `obj`. It's also known as "property access" or "in operator" method.
    *   **Pros:** Works for both properties and methods (i.e., it can check if an object has a property called 'foo' or method called foo()).
    *   **Cons:** May be slower than direct comparisons, especially when dealing with large objects.
*   **`obj.hasOwnProperty('f')`**: This approach checks if `obj` has a property called `'f'`, which is the most common use case for this method. However, it may not work correctly if `obj.f` has been overridden or deleted.
    *   **Pros:** Works when checking if an object has a specific property and its value.
    *   **Cons:** May not work correctly in certain edge cases (e.g., overriding or deleting properties).

In summary, each method has its strengths and weaknesses. The best approach depends on the specific requirements of your application:

*   Use `undefined === obj.f` when checking if a specific property is explicitly set to undefined.
*   Use `'undefined' === typeof obj.d` when you need to check for an undefined value, even if it's not explicitly set (e.g., due to falsy values).
*   Use `'f' in obj` when working with large objects or needing to check for both properties and methods.

The `hasOwnProperty` method is generally used to check if a property belongs to the object itself, rather than inherited from its prototype chain.

Latest run results:

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

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

Browser/OS: Chrome 93 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
undefined	4520869.0 Ops/sec
typeof	12637707.0 Ops/sec
in	12681154.0 Ops/sec
hasOwnProperty	10701274.0 Ops/sec

Related benchmarks:

Object lookup perf undefined vs. typeof vs. in vs. hasOwnProperty (version: 0)

Object lookup performance

Comparing performance of: undefined vs typeof vs in vs hasOwnProperty

Created: 3 years ago by: Guest

Jump to the latest result

undefined

typeof

in

hasOwnProperty

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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