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

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.prototype.toString.call(obj) === "[object Object]"
Object.prototype.toString.call reverse
"[object Object]" === Object.prototype.toString.call(obj)
constructor
(!!obj) && (obj.constructor === Object)
costructor reverse
(!!obj) && (Object === obj.constructor)
costructor ?.
Object === obj?.constructor

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 reverse
constructor
costructor reverse
costructor ?.

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 break down the provided benchmark and explain what's being tested.

The benchmark is comparing different ways to check if an object is of type `Object` or its constructor. The objective is to determine which method is faster.

Here are the options being compared:

1. `instanceof Object`: This checks if the object is an instance of the `Object` constructor.
2. `typeof obj === 'object'`: This uses the `typeof` operator to check if the object is an object.
3. `typeof obj === 'object' && typeof obj !== 'function'`: This is a variation of the previous option that checks if the object is not a function.
4. `Object.prototype.toString.call(obj) === "[object Object]"`: This uses the `toString()` method on the `Object` prototype to check if the object's string representation is `"[object Object]"`.
5. `"_[object Object]_" === Object.prototype.toString.call(obj)`: This is similar to the previous option, but with a different syntax for comparison.
6. `(!!obj) && (obj.constructor === Object)`: This uses a boolean trick (`!!` operator) to check if `obj` is truthy and its constructor is equal to `Object`.
7. `(!!obj) && (Object === obj.constructor)`: This variation checks if `Object` is equal to the object's constructor.
8. `Object === obj?.constructor`: This option uses optional chaining (`?.`) to access the constructor property of the object.

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

1. `instanceof Object`: This method is straightforward and easy to read, but it may be slower due to the overhead of the instanceof operator.
2. `typeof obj === 'object'`: This method is simple and fast, but it can return false positives if the object's prototype chain contains other objects.
3. `typeof obj === 'object' && typeof obj !== 'function'`: Similar to the previous option, but with an additional check for non-functionality.
4. `Object.prototype.toString.call(obj) === "[object Object]"`: This method is specific to JavaScript and may be slower due to the use of the prototype chain. However, it's a good option if you want to check for object-type specifically.
5. `"_[object Object]_" === Object.prototype.toString.call(obj)`: Similar to the previous option, but with a different syntax for comparison.
6. `(!!obj) && (obj.constructor === Object)`: This method uses a boolean trick to simplify the comparison. It's fast and straightforward, but may be less intuitive for some readers.
7. `(!!obj) && (Object === obj.constructor)`: Similar to the previous option, but with an additional check for identity equality between `Object` and the constructor.
8. `Object === obj?.constructor`: This option uses optional chaining to access the constructor property of the object. It's a modern syntax that may be unfamiliar to some readers.

In terms of other alternatives, there are several methods you could use to check if an object is of type Object:

* Using `instanceof` with a different class: `instanceof MyClass`
* Using a library like Lodash: `_isObject(obj)`
* Using a polyfill for `Object.is`: `Object.is(obj, Object)`

It's worth noting that the best approach depends on the specific requirements and constraints of your use case.

The latest benchmark results show that the fastest method is `(!!obj) && (obj.constructor === Object)`, followed closely by `typeof obj === 'object'`. However, it's essential to keep in mind that microbenchmarks like this can be sensitive to specific input data and implementation details.

Related benchmarks:

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

Comparing performance of: instanceof vs typeof vs typeof no function vs Object.prototype.toString.call vs Object.prototype.toString.call reverse vs constructor vs costructor reverse vs costructor ?.

Created: 3 years ago by: Guest

Jump to the latest result

instanceof

typeof

typeof no function

Object.prototype.toString.call

Object.prototype.toString.call reverse

constructor

costructor reverse

costructor ?.

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