Benchmark: Check properties in an object

Script Preparation code:

var obj = {
  'undefined': undefined,
  'null': null,
  'zero': 0,
  'one': 1,
  'symbol': Symbol('symbol')
};

var properties = ['test', 'one', 'symbol', 'null', 'zero', 'undefined', 'toString'];

var testResult = (obj, method, ...properties) => {
  let result = 0;
  for(let prop of properties) {
    if(method(obj, prop)) {
      result++;
    }
  }
  return result;
}

Tests:

Truthy
testResult(obj, (o, p) => !!o[p], ...properties)
HasOwnProperty
testResult(obj, (o, p) => o.hasOwnProperty(p), ...properties)
In
testResult(obj, (o, p) => p in o, ...properties)
Typeof
testResult(obj, (o, p) => 'undefined' !== typeof o[p], ...properties)
Undefined
testResult(obj, (o, p) => undefined !== o[p], ...properties)
Void
testResult(obj, (o, p) => void(0) !== o[p], ...properties)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Truthy
HasOwnProperty
In
Typeof
Undefined
Void

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the Benchmark Definition and test cases.

**Benchmark Definition**

The provided JSON represents a JavaScript microbenchmarking framework, MeasureThat.net. The benchmark is designed to measure the performance of different approaches for checking properties in an object.

In the Script Preparation Code section, we can see that an object `obj` is created with various properties (including `undefined`, `null`, `zero`, `one`, and a symbol). Additionally, an array `properties` is defined, which contains the names of the properties to be checked. The `testResult` function takes three arguments: `obj`, `method` (a callback function), and `...properties`. It iterates over the `properties` array, calling the `method` function for each property and incrementing a result counter if the method returns true.

**Options Compared**

The benchmark compares different approaches for checking properties in an object:

1. **Truthy**: Using the `!!o[p]` expression to check if a property exists.
2. **HasOwnProperty**: Using the `o.hasOwnProperty(p)` method to check if a property is owned by the object.
3. **In**: Using the `p in o` syntax to check if a property exists in the object.
4. **Typeof**: Using the `'undefined' !== typeof o[p]` expression to check if a property exists and has a specific type (in this case, undefined).
5. **Undefined**: Using the `undefined !== o[p]` expression to check if a property is not undefined.
6. **Void**: Using the `void(0) !== o[p]` expression to check if a property is not null or undefined.

**Pros and Cons of Different Approaches**

Here's a brief overview of each approach:

* **Truthy**: This approach is simple and widely supported, but it may have performance issues for very large objects due to the overhead of the `!!` operator.
* **HasOwnProperty**: This method is more efficient than the `Truthy` approach, as it uses a native method that bypasses JavaScript's type checking. However, it requires an additional function call.
* **In**: This syntax is supported by modern browsers and can be faster than the other approaches due to its use of compiler optimizations. However, it may not work in older browsers or environments.
* **Typeof**: This approach has performance issues due to the overhead of the `typeof` operator, which may lead to slower execution times compared to other methods.
* **Undefined**: Similar to `Typeof`, this approach is slow due to the overhead of the `===` operator.
* **Void**: This expression is generally fast and efficient, as it uses a native function call that bypasses JavaScript's type checking.

**Library Usage**

The benchmark uses no external libraries or dependencies. However, some approaches rely on native methods or syntax that may be specific to certain browsers or environments.

**Special JS Features or Syntax**

No special JavaScript features or syntax are used in this benchmark. The code is designed to be platform-agnostic and compatible with most modern browsers.

**Other Alternatives**

There are other alternatives for checking properties in an object, such as:

* Using `in` operator: This approach can be faster than the others due to its use of compiler optimizations.
* Using `Object.keys()` method: This approach can be slower due to the overhead of the function call and iteration over the keys array.

Keep in mind that these alternatives may not be supported by all browsers or environments.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36

Browser/OS: Chrome 67 on Windows

View result in a separate tab

Test name	Executions per second
Truthy	1920725.6 Ops/sec
HasOwnProperty	2204818.0 Ops/sec
In	2256228.0 Ops/sec
Typeof	1956624.5 Ops/sec
Undefined	511981.2 Ops/sec
Void	2107397.5 Ops/sec

Related benchmarks:

Check properties in an object (version: 11)

Check properties in an object

Comparing performance of: Truthy vs HasOwnProperty vs In vs Typeof vs Undefined vs Void

Created: 6 years ago by: Registered User

Jump to the latest result

Truthy

HasOwnProperty

In

Typeof

Undefined

Void

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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