Benchmark: isArray - fork1 - MeasureThat.net

Script Preparation code:

var toStr = Object.prototype.toString
	
function toStrCase(obj){
  return obj.toString() === '[object Array]'
}
function consCase(obj){
  return obj?.constructor === Array
}
function instCase(obj){
  return obj instanceof Array
}

var isArray = Array.isArray

Tests:

Array.isArray
isArray([])
instanceof
instCase([])
[].constructor
consCase([])
Object.prototype.toString
toStrCase([])

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: 4 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.1 Safari/605.1.15

Browser/OS: Safari 14 on Mac OS X 10.15.6

View result in a separate tab

Test name	Executions per second
Array.isArray	9441820.0 Ops/sec
instanceof	3791492.2 Ops/sec
[].constructor	3761278.5 Ops/sec
Object.prototype.toString	7718196.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its options.

**Benchmark Overview**

The benchmark, `isArray - fork1`, tests four different approaches to determine if an object is an array:

1. `Array.isArray`
2. `Object.prototype.toString` (specifically, checking for `[object Array]`)
3. `[].constructor` (checking if the constructor is `Array`)
4. `instanceof Array`

**Approach 1: `Array.isArray`**

This approach uses the built-in `Array.isArray()` method to check if an object is an array.

Pros:

* Fast and efficient, as it's a native method.
* Well-documented and widely supported.

Cons:

* May not work correctly for certain types of objects (e.g., `Map`, `Set`).
* Can be slower than other approaches in some cases.

**Approach 2: `Object.prototype.toString`**

This approach uses the `toString()` method on the object to check if it's an array. The method is called with `[object Array]` as a string argument to specifically test for arrays.

Pros:

* Works well for most objects, including `Map` and `Set`.
* Can be faster than other approaches in some cases.

Cons:

* May not work correctly for certain edge cases (e.g., objects with `toString()` overridden).
* Requires JavaScript engine support for the `Object.prototype.toString()` method.

**Approach 3: `[].constructor`**

This approach uses the constructor of an empty array (`[]`) to check if an object is an array. The `instanceof` operator is used to compare the object's constructor with the array constructor.

Pros:

* Fast and efficient, as it's a simple comparison.
* Works well for most objects, including `Map` and `Set`.

Cons:

* May not work correctly for certain edge cases (e.g., objects with overridden constructors).
* Requires JavaScript engine support for the `instanceof` operator.

**Approach 4: `instanceof Array`**

This approach uses the `instanceof` operator to check if an object is a direct instance of the `Array` constructor.

Pros:

* Works well for most objects, including `Map` and `Set`.
* Is a straightforward and easy-to-understand approach.

Cons:

* May be slower than other approaches in some cases.
* Requires JavaScript engine support for the `instanceof` operator.

**Other Considerations**

When choosing an approach, consider the specific use case and requirements. For example, if you need to handle `Map` or `Set` objects, Approach 2 (`Object.prototype.toString`) might be a better choice. If you're targeting older browsers that don't support `instanceof`, Approach 4 might not work.

**Library**

The benchmark uses no external libraries. The tests are self-contained and rely on built-in JavaScript methods and operators.

**Special JS Features/Syntax**

There is no mention of special JavaScript features or syntax in the provided benchmark.

Related benchmarks:

isArray - fork1 (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: 4 years ago by: Registered User

Jump to the latest result

Array.isArray

instanceof

[].constructor

Object.prototype.toString

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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