Benchmark: instanceof vs typeof vs prop check

Script Preparation code:

var obj = {a:2};

Tests:

instanceof
obj instanceof Object
typeof
typeof obj === 'object'
typeof no function
typeof obj === 'object' && typeof obj !== 'function'
typeof and test attribute
obj.a

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
instanceof
typeof
typeof no function
typeof and test attribute

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 138 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
instanceof	67041096.0 Ops/sec
typeof	62435656.0 Ops/sec
typeof no function	66435056.0 Ops/sec
typeof and test attribute	65773104.0 Ops/sec

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 and explore what's tested in this benchmark.

**Benchmark Overview**

The provided JSON represents a JavaScript benchmark that tests the performance of three different approaches to check if an object is "of type" or "has a property". The benchmarks are designed to measure the execution time, speed, and efficiency of each approach.

**Options being compared**

There are three options being compared in this benchmark:

1. `obj instanceof Object`: This checks if the object is an instance of the `Object` class.
2. `typeof obj === 'object'`: This checks if the type of the object is `'object'`.
3. `typeof obj === 'object' && typeof obj !== 'function'`: This checks if the type of the object is `'object'` and not `'function'`.

**Pros and Cons of each approach**

1. `obj instanceof Object`:
	* Pros: Simple, straightforward, and widely supported.
	* Cons: Can be slower due to the overhead of the `instanceof` operator.
2. `typeof obj === 'object'`:
	* Pros: Faster than `instanceof`, as it only checks the type of the object.
	* Cons: May not work correctly for some types (e.g., arrays, functions), and can be slow if the type is `'object'`.
3. `typeof obj === 'object' && typeof obj !== 'function'`:
	* Pros: Provides a more specific check than just checking for `'object'`, which can improve performance.
	* Cons: May still not work correctly for some types (e.g., arrays, functions), and requires an additional type check.

**Library usage**

None of the benchmark tests use any libraries or external dependencies. The code is self-contained and uses only built-in JavaScript features.

**Special JS feature or syntax**

There are no special JS features or syntax used in this benchmark. It's designed to be simple, straightforward, and easy to understand.

**Other alternatives**

If you're interested in exploring alternative approaches, here are a few options:

1. Use a type checker library like `type-check` or `ts-type`.
2. Implement a custom type checking function using JavaScript's built-in `Object.prototype.toString()` method.
3. Use a caching library to memoize the results of each check.

Keep in mind that these alternatives may introduce additional complexity, dependencies, or performance overhead. The original benchmark code provides a simple and straightforward way to test the performance of different approaches.

Related benchmarks:

instanceof vs typeof vs prop check (version: 0)

Comparing performance of: instanceof vs typeof vs typeof no function vs typeof and test attribute

Created: 3 years ago by: Guest

Jump to the latest result

instanceof

typeof

typeof no function

typeof and test attribute

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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