Toggle navigation
MeasureThat.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
instanceOf vs __proto__
(version: 1)
Comparing performance of:
instanceOf vs __proto__
Created:
one year ago
by:
Registered User
Jump to the latest result
Script Preparation code:
var a = new Map();
Tests:
instanceOf
console.log(a instanceof Map)
__proto__
console.log(a.__proto__ === Map.prototype)
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
instanceOf
__proto__
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
one year ago
)
User agent:
Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:138.0) Gecko/20100101 Firefox/138.0
Browser/OS:
Firefox 138 on Windows
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=606709" width="100%" height="500px"></iframe>
Test name
Executions per second
instanceOf
136886.2 Ops/sec
__proto__
139091.8 Ops/sec
Autogenerated LLM Summary
(model
gpt-4o-mini
, generated one year ago):
The benchmark defined in the provided JSON tests the performance comparison between two different methods for verifying an object's prototype relationship in JavaScript: using `instanceof` and using the `__proto__` property. ### Options Compared 1. **instanceof Operator** - **Benchmark Definition**: `console.log(a instanceof Map)` - **Test Name**: `instanceOf` - **Purpose**: This operator checks if an object (in this case, `a`) is an instance of a specific constructor function (in this case, `Map`). It takes into account the entire prototype chain, meaning if `Map.prototype` is found somewhere up the chain, the result is `true`. 2. **__proto__ Property** - **Benchmark Definition**: `console.log(a.__proto__ === Map.prototype)` - **Test Name**: `__proto__` - **Purpose**: The `__proto__` property directly accesses an object’s prototype. The comparison checks if `a`’s immediate prototype is the same as `Map.prototype`. This approach only verifies the direct prototype relationship. ### Pros and Cons **instanceof:** - **Pros**: - More robust as it traverses the entire prototype chain. - Works correctly even if the prototype is set up incorrectly or if inheritance is involved. - **Cons**: - Slightly slower than direct checks because it performs a search up the prototype chain. **__proto__:** - **Pros**: - Generally faster as it only checks the immediate prototype. - Simpler and more straightforward for scenarios where direct verification is all that is required. - **Cons**: - Less reliable for complex inheritance structures. - Could lead to misleading results if the prototype has been modified. ### Other Considerations When deciding which approach to use, the context in which the code will run is crucial. If you need to ensure that a certain type of object is being used (especially in complex hierarchies), `instanceof` is the safer choice. However, if performance is critical, and you are certain of the prototype structure, checking `__proto__` may be tempting. ### Alternatives Other alternatives for checking prototype relationships include: - **Using `Object.getPrototypeOf()`**: This method can be used to retrieve the prototype of an object. For example: ```javascript Object.getPrototypeOf(a) === Map.prototype; ``` This method is generally preferred in modern codebases over `__proto__`, as it provides better readability and is part of the official JavaScript standard. - **Using `isPrototypeOf()` Method**: You can also check if `Map.prototype` is in the prototype chain of `a`: ```javascript Map.prototype.isPrototypeOf(a); ``` This method works similarly to `instanceof` but serves to be more explicit about the prototype relationship logic. In a nutshell, this benchmark is essential for understanding the performance implications of different prototype verification methods in JavaScript, helping developers choose the best approach based on their use case.
Related benchmarks:
typeof vs instanceof vs null
typeof vs instanceof Function
instanceof vs null
typeof_vs_instanceof
instanceof vs typeof for objects
JS instanceof vs in
instanceof vs number
instanceof vs typeof franco
instanceof vs typeof vs !!
Comments
Confirm delete:
Do you really want to delete benchmark?