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

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:140.0) Gecko/20100101 Firefox/140.0

Browser/OS: Firefox 140 on Linux

View result in a separate tab

Test name	Executions per second
instanceof	121985584.0 Ops/sec
typeof	1285562240.0 Ops/sec
typeof no function	1106768384.0 Ops/sec
Object.prototype.toString.call ==	1449307776.0 Ops/sec
Object.prototype.toString.call ===	1562626688.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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

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: 3 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>

Fastest: N/A

Slowest: N/A

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