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

instanceof vs typeof vs Object.prototype.toString.call vs constructor vs constructor.name (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 ?. vs constructor.name ?. vs constructor.name ?. reverse`

Created: 3 years ago by: Guest

Go to the latest result

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
constructor.name ?.
obj?.constructor.name === "Object"
constructor.name ?. reverse
"Object" === obj?.constructor.name

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

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36

Browser/OS: Chrome 139 on Windows

View result in a separate tab

typeof no function

150.3M/s

constructor

141.8M/s

costructor ?.

141.3M/s

costructor reverse

140.9M/s

typeof

130.3M/s

instanceof

103.4M/s

Object.prototype.toString.call

75.5M/s

Object.prototype.toString.call reverse

71.8M/s

constructor.name ?.

53.5M/s

constructor.name ?. reverse

52.2M/s

View exact numbers

Test name	Executions per second
✓ typeof no function	150,293,360 Ops/sec
constructor	141,803,200 Ops/sec
costructor ?.	141,261,856 Ops/sec
costructor reverse	140,911,408 Ops/sec
typeof	130,307,720 Ops/sec
instanceof	103,426,640 Ops/sec
Object.prototype.toString.call	75,461,896 Ops/sec
Object.prototype.toString.call reverse	71,820,624 Ops/sec
constructor.name ?.	53,540,336 Ops/sec
constructor.name ?. reverse	52,193,756 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 on MeasureThat.net.

**Benchmark Overview**

The provided benchmark measures the performance of various ways to check if an object is an instance of a particular constructor, and also checks the type of the object, its function status, or uses the `toString` method. We'll explore each option individually.

**Options Compared**

1. **`instanceof`**: This operator checks if an object is an instance of a specific constructor.
2. **`typeof`**: This operator returns a string indicating the type of an object (e.g., "object", "function").
3. **`Object.prototype.toString.call(obj)`**: This method calls the `toString` method on the `Object.prototype` and passes the object as an argument, returning its string representation.
4. **Constructor Check**: Some options check if the constructor property is set to a specific value (e.g., `constructor === Object`, `obj.constructor === Object`).
5. **Optional Chaining (`?.`)**: Some options use optional chaining (`?.`) to access the `name` property of the constructor, which returns `undefined` if it's not set.

**Pros and Cons**

1. **`instanceof`**:
	* Pros: Fast and straightforward.
	* Cons: May not work correctly for objects that inherit from multiple constructors.
2. **`typeof`**:
	* Pros: Simple and efficient.
	* Cons: Returns a string, which may not be what the developer expects (e.g., "object" instead of "Object").
3. **`Object.prototype.toString.call(obj)`**:
	* Pros: Can return a more informative result than `typeof`.
	* Cons: May be slower due to the method call and the need to access `Object.prototype`.
4. **Constructor Check**:
	* Pros: Can provide additional information about the object's constructor.
	* Cons: May be slower or less efficient than other options.
5. **Optional Chaining (`?.`)**:
	* Pros: Provides a concise way to access properties with optional chaining.
	* Cons: May not work correctly if the property is not set, and it can lead to silent failures.

**Library Used**

`Object.prototype.toString.call()` uses the `toString` method on the `Object.prototype`, which is a built-in JavaScript object. The other options use the `instanceof` operator or access the `constructor` property directly.

**Benchmarks**

The provided benchmark results show that:

* `instanceof` and `typeof` are generally fast, with similar performance.
* `Object.prototype.toString.call(obj)` is slower than `instanceof` and `typeof`, but still relatively efficient.
* Constructor checks are slower due to the additional property access or method calls.
* Optional chaining (`?.`) can provide a concise way to access properties, but may lead to silent failures if not used carefully.

**Conclusion**

The choice of option depends on the specific use case and performance requirements. If you need a simple and fast way to check if an object is an instance of a constructor, `instanceof` or `typeof` might be a good choice. However, if you need more informative results or want to access additional properties, options like `Object.prototype.toString.call(obj)` or Constructor Check might be necessary. Optional chaining (`?.`) can provide a concise way to access properties, but requires careful consideration of its usage and potential silent failures.