Benchmark: instanceof vs typeof vs Object.prototype.toString.call

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'
Object.prototype.toString.call ==
"[object Object]" == Object.prototype.toString.call(obj)
Object.prototype.toString.call ===
"[object Object]" === Object.prototype.toString.call(obj)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
instanceof
typeof
typeof no function
Object.prototype.toString.call ==
Object.prototype.toString.call ===

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down what is being tested in this JavaScript microbenchmark on MeasureThat.net.

The benchmark compares four different ways to check if an object is of type `Object`. The tests are:

1. `obj instanceof Object`: This checks if the object `obj` is an instance of the `Object` constructor.
2. `typeof obj === 'object'`: This uses the `typeof` operator to get the type of `obj` as a string and checks if it's equal to `'object'`.
3. `typeof obj === 'object' && typeof obj !== 'function'`: This is similar to the previous test, but also excludes functions from being considered as objects.
4. `" [object Object] " == Object.prototype.toString.call(obj)` and `" [object Object] " === Object.prototype.toString.call(obj)`: These tests compare the result of calling `Object.prototype.toString.call(obj)` with a hardcoded string.

Now, let's discuss the pros and cons of each approach:

**1. `obj instanceof Object`**

Pros: This is the most straightforward way to check if an object is an instance of the `Object` constructor. It's also relatively fast.

Cons: The performance can be slower than the other methods because it involves a function call and a string comparison.

**2. `typeof obj === 'object'`**

Pros: This method is simple and easy to understand, but it has some drawbacks. The type of an object can change depending on its context (e.g., when used as an array), so this check might not always work as expected.

Cons: This method is slower than the others because it involves a string comparison and might trigger some optimizations in modern JavaScript engines that try to avoid comparing objects with strings.

**3. `typeof obj === 'object' && typeof obj !== 'function'`**

Pros: This approach excludes functions from being considered as objects, which can be useful in certain scenarios. It's also slightly faster than the first two methods because it eliminates one unnecessary function call and string comparison.

Cons: The performance is still relatively slow due to the use of `typeof` with a string literal.

**4. `" [object Object] " == Object.prototype.toString.call(obj)`**

Pros: This method uses the fact that `Object.prototype.toString.call()` returns a string representing the type of an object. By comparing this string to a hardcoded value, it avoids using `typeof`, which can be optimized by modern engines.

Cons: This approach is slower than the others because it involves calling a function (`Object.prototype.toString.call()`) and performing a string comparison.

In general, if you need to check if an object is of type `Object` frequently, the first two methods are likely to be faster. However, the fourth method might provide more accurate results when dealing with non-native objects or objects in certain contexts.

Other alternatives for testing this benchmark include:

* Using a different programming language (e.g., Python, Java) to run the same test
* Testing on different browsers or versions of Chrome to see if there are browser-specific differences
* Modifying the test cases to cover more edge cases (e.g., objects with custom constructors, null values)
* Analyzing the benchmark results to identify patterns or trends that might not be immediately apparent

Latest run results:

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

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

Browser/OS: Chrome 107 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
instanceof	9554441.0 Ops/sec
typeof	27036840.0 Ops/sec
typeof no function	13531331.0 Ops/sec
Object.prototype.toString.call ==	9072113.0 Ops/sec
Object.prototype.toString.call ===	9048240.0 Ops/sec

Related benchmarks:

instanceof vs typeof vs Object.prototype.toString.call (version: 0)

Comparing performance of: instanceof vs typeof vs typeof no function vs Object.prototype.toString.call == vs Object.prototype.toString.call ===

Created: 2 years ago by: Guest

Jump to the latest result

instanceof

typeof

typeof no function

Object.prototype.toString.call ==

Object.prototype.toString.call ===

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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