Benchmark: Array.isArray vs Object.prototype.toString vs [].constructor vs instanceof

Tests:

Array.isArray
Array.isArray([])
instanceof
[] instanceof Array
[].constructor
[].constructor === Array
Object.prototype.toString
Object.prototype.toString.call([]) === '[object Array]'

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.isArray
instanceof
[].constructor
Object.prototype.toString

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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36 Edg/136.0.0.0

Browser/OS: Chrome 136 on Windows

View result in a separate tab

Test name	Executions per second
Array.isArray	128821568.0 Ops/sec
instanceof	93999448.0 Ops/sec
[].constructor	110363120.0 Ops/sec
Object.prototype.toString	64276124.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's being tested in the provided JSON.

**Benchmark Overview**

The benchmark is designed to compare four different approaches for checking if an object is an array:

1. `Array.isArray()`
2. `instanceof Array`
3. `[].constructor === Array`
4. `Object.prototype.toString.call([]) === '[object Array]'`

These methods are compared in the context of creating and manipulating empty arrays.

**Options Comparison**

Here's a brief overview of each option, their pros and cons:

1. **`Array.isArray()`**: This is a built-in JavaScript function that returns `true` if the object passed to it is an array-like object (including arrays). Pros: simple, concise, and widely supported. Cons: may return incorrect results for non-array-like objects.
2. **`instanceof Array`**: This method checks if an object is an instance of the `Array` constructor. Pros: accurate for most cases, but it only works with constructors that have a built-in `prototype` property. Cons: may not work as expected with certain types of objects (e.g., functions or non-constructor objects).
3. **`[].constructor === Array`**: This approach checks if the constructor property of an array is equal to the `Array` constructor. Pros: accurate and type-safe, but it requires knowledge of constructors and may be less readable than other options. Cons: less common use cases.
4. **`Object.prototype.toString.call([]) === '[object Array]'`**: This method uses a helper function (`toString`) from `Object.prototype` to check if the result is an array representation. Pros: accurate, but it relies on internal implementation details of `Object.prototype.toString`. Cons: may break with changes to JavaScript engines or implementations.

**Library and Special JS Features**

None of the test cases use external libraries or special JavaScript features beyond what's required for basic syntax checking.

**Other Alternatives**

Other methods for checking if an object is an array might include:

* Using `Array.prototype.forEach()` (not tested in this benchmark)
* Implementing a custom "is-array" function using bitwise operations
* Using a third-party library like Lodash

Keep in mind that the specific use cases and requirements may affect the choice of alternative methods.

Let me know if you have any further questions!

Related benchmarks:

Array.isArray vs Object.prototype.toString vs [].constructor vs instanceof (version: 0)

Array.isArray vs Object.prototype.toString vs [].constructor vs instanceof

Comparing performance of: Array.isArray vs instanceof vs [].constructor vs Object.prototype.toString

Created: 2 years ago by: Guest

Jump to the latest result

Array.isArray

instanceof

[].constructor

Object.prototype.toString

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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