Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
FAQ
Register
Log In
isarray_vs_instanceof_vs_tostring
(version: 0)
Comparing performance of:
isArray vs instanceof vs toString
Created:
4 years ago
by:
Guest
Go to the latest result
Tests:
isArray
const i = Array.isArray([]);
instanceof
const i = [] instanceof Array;
toString
const i = Object.prototype.toString.call([]) === '[object Array]';
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (3)
Previous results
Fork
Test case name
Result
isArray
instanceof
toString
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
one year ago
)
User agent:
Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36
Browser/OS:
Chrome 126 on Chrome OS 14541.0.0
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=596761" width="100%" height="500px"></iframe>
isArray
54.3M/s
instanceof
35.6M/s
toString
18.5M/s
View exact numbers
Test name
Executions per second
✓
isArray
54,255,020 Ops/sec
instanceof
35,619,524 Ops/sec
toString
18,517,550 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
Measuring JavaScript performance is a crucial aspect of developing efficient and scalable applications. The provided JSON represents a benchmark test on MeasuringThat.net, which compares the performance of three different approaches to check if an object is an array. **Approaches being compared:** 1. **`Array.isArray()`**: This method returns a boolean value indicating whether the input `i` is an array. 2. **`instanceof Array`**: This syntax checks if the object `i` is an instance of the `Array` constructor. 3. **`Object.prototype.toString.call(i) === '[object Array]'`**: This approach uses the `toString()` method to convert the object `i` to a string and then compares it with the expected string representation of an array. **Pros and Cons of each approach:** 1. **`Array.isArray()`**: * Pros: Fast, lightweight, and widely supported. * Cons: May return false positives for certain types of objects that inherit from `Array`. (e.g., `Map`, `Set`) 2. **`instanceof Array`**: * Pros: More accurate than `Array.isArray()` for objects that are instances of `Array`. * Cons: Can be slower due to the overhead of the `instanceof` operator. 3. **`Object.prototype.toString.call(i) === '[object Array]'`**: * Pros: Robust and accurate, as it checks the object's prototype chain. * Cons: May be slower due to the overhead of calling a method on `Object.prototype`. **Libraries and special features:** No libraries are used in this benchmark. There are no special JavaScript features or syntax mentioned. **Other alternatives:** For checking if an object is an array, other approaches could include: 1. Using the `constructor` property: `i.constructor === Array` 2. Checking for specific properties: `i.length > 0 && typeof i[0] === 'undefined'` 3. Using a library like Lodash's `isArray()` function These alternatives may have different performance characteristics and trade-offs, depending on the specific use case. **Benchmark preparation code analysis:** The provided script preparation code is empty, which means that no additional setup or initialization is required for this benchmark. In conclusion, this benchmark provides a useful comparison of three approaches to check if an object is an array. Understanding the pros and cons of each approach can help developers choose the most efficient and accurate method for their specific use case.
Related benchmarks
Array isArray vs instanceof
Array isArray vs instanceof 2
Array: Object.prototype.toString vs instanceof vs Array.isArray
instanceof Array vs Array.isArray
Comments
Confirm delete:
Do you really want to delete benchmark?