Benchmark: undefined vs. typeof vs. in vs. hasOwnProperty vs wrapped function

Script Preparation code:

var obj = { a: 1, b: 2, c: 3, d: 4, e: 5 };
var undef;

function isDefined (o) {
    return typeof o !== "undefined";
}

const isDefined2 = (o) => {
    return typeof o !== "undefined";
}

const isDefined3 = (o) => typeof o !== "undefined";


const Sys = {
	isDefined (o) {
    	return typeof o !== "undefined";
	}

}

Tests:

undefined
undefined !== obj.d;
typeof
'undefined' !== typeof obj.d;
in
'd' in obj;
hasOwnProperty
obj.hasOwnProperty( 'd' );
truthy
!! obj.d;
local undef
undef !== obj.d;
isDefined
isDefined(obj.d)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
undefined
typeof
in
hasOwnProperty
truthy
local undef
isDefined

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

**Benchmark Definition JSON**

The provided `Benchmark Definition` JSON represents a set of test cases for measuring object lookup performance in JavaScript. The benchmark consists of six different approaches:

1. `undefined !== obj.d;`
2. `'undefined' !== typeof obj.d;`
3. `'d' in obj;`
4. `obj.hasOwnProperty('d');`
5. `!! obj.d;` (truthy value test)
6. `undef !== obj.d;` (local variable test)

**Approaches Compared**

Each approach is being compared to measure its performance difference.

**Pros and Cons of Different Approaches:**

1. **`undefined !== obj.d;`**
	* Pros: Simple, straightforward comparison.
	* Cons: May not cover all edge cases, like `obj.d` being `null` or `undefined`.
2. ** `'undefined' !== typeof obj.d;`**
	* Pros: More robust than the previous approach, as it checks for both value and type equality.
	* Cons: May be slower due to the additional check (`typeof`).
3. ** `'d' in obj;`**
	* Pros: Efficiently checks if a property exists on an object.
	* Cons: May not work as expected with `null` or `undefined` values.
4. ** `obj.hasOwnProperty('d');`**
	* Pros: More accurate than the previous approach, as it explicitly checks for property existence.
	* Cons: May be slower due to the additional method call (`hasOwnProperty`).
5. ** `!! obj.d;` (truthy value test)`
	* Pros: Simple and efficient way to check if a value is truthy.
	* Cons: Only works with numeric values, not strings or objects.
6. ** `undef !== obj.d;`**
	* Pros: A simple variable comparison.
	* Cons: May not cover all edge cases, like `obj.d` being `null` or `undefined`.

**Library Usage**

None of the provided approaches use any external libraries.

**Special JS Features or Syntax**

The benchmark uses several JavaScript features:

1. **Arrow functions**: Used in `const isDefined2 = (o) => { return typeof o !== "undefined"; };`
2. **Template literals**: Used in `var undef;`
3. **Nullish Coalescing Operator (`??`)**: Not used, but the benchmark uses `!! obj.d;` which has similar behavior.

**Other Alternatives**

For measuring object lookup performance, other alternatives include:

1. Checking if a property exists using `in` or `hasOwnProperty`.
2. Using a library like `lodash` with its `getIn` function.
3. Creating a custom function for checking property existence.

Keep in mind that the choice of approach depends on the specific use case and requirements.

**Benchmark Preparation Code**

The provided script preparation code sets up an object `obj` with properties `a`, `b`, `c`, `d`, and `e`. It also defines several functions:

1. `isDefined(o)`: Checks if a value is not `undefined`.
2. `const isDefined2 = (o) => { return typeof o !== "undefined"; };`: An arrow function for the same purpose as `isDefined`.
3. `const isDefined3 = (o) => typeof o !== "undefined";`: A traditional function for the same purpose.
4. The `Sys` object with its own implementation of `isDefined(o)`.

The script preparation code does not use any external libraries or features beyond those already described.

Related benchmarks:

undefined vs. typeof vs. in vs. hasOwnProperty vs wrapped function (version: 0)

Object lookup performance

Comparing performance of: undefined vs typeof vs in vs hasOwnProperty vs truthy vs local undef vs isDefined

Created: 7 years ago by: Registered User

Jump to the latest result

undefined

typeof

in

hasOwnProperty

truthy

local undef

isDefined

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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