Benchmark: isArray - MeasureThat.net

Script Preparation code:

var toStr = Object.prototype.toString
	
function toStrCase(obj){
  return toStr.call(obj) === '[object Array]'
}
function consCase(obj){
  return obj && obj.constructor === Array
}
function instCase(obj){
  return obj && 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: 2 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:148.0) Gecko/20100101 Firefox/148.0

Browser/OS: Firefox 148 on Windows

View result in a separate tab

Test name	Executions per second
Array.isArray	529489472.0 Ops/sec
instanceof	249741008.0 Ops/sec
[].constructor	480591968.0 Ops/sec
Object.prototype.toString	236849552.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark and explain what's being tested, compared, and other considerations.

**Benchmark Overview**

The `isArray` benchmark compares four different approaches to check if an object is an array:

1. `Array.isArray`
2. `Object.prototype.toString` using a custom `toStrCase` function
3. `[] .constructor`
4. `instanceof Array`

These approaches are compared in various test cases, including testing each approach on an empty array (`[]`).

**Approaches Compared**

Here's a brief explanation of each approach:

1. **`Array.isArray`**: This is a built-in JavaScript method that returns a boolean indicating whether the object passed to it is an array.
2. **`Object.prototype.toString` with `toStrCase` function**: The `Object.prototype.toString` method returns a string representation of the object, which can be compared to the string `'[object Array]'`. The custom `toStrCase` function checks if this string matches the expected output. This approach is more verbose but allows for custom comparison logic.
3. **`[] .constructor`**: This approach uses the `constructor` property of an empty array (`[]`) to check if it's an array. Since arrays have a specific constructor, this method can be used to detect array-like objects.
4. **`instanceof Array`**: This is another built-in JavaScript method that returns a boolean indicating whether the object passed to it is an instance of `Array`. However, since `[]` is not an instance of `Array`, this approach will return false.

**Pros and Cons**

Here are some pros and cons for each approach:

1. **`Array.isArray`**: Pros - simple and concise; Cons - may be slower due to the additional method call.
2. **`Object.prototype.toString` with `toStrCase` function**: Pros - allows for custom comparison logic; Cons - more verbose, potentially slower due to the custom function call.
3. **`[] .constructor`**: Pros - simple and efficient; Cons - may not work correctly for non-array-like objects.
4. **`instanceof Array`**: Pros - concise; Cons - will return false for `[]`, making it less suitable.

**Library Used**

The `toStrCase` function uses the `Object.prototype.toString` method, which is a built-in JavaScript method.

**Special JS Feature or Syntax**

None of the approaches use any special JavaScript features or syntax. They are all standard JavaScript methods and properties.

**Other Alternatives**

Some alternative approaches to check if an object is an array include:

* Using the `typeof` operator with `'array'`: `typeof obj === 'array'`
* Using a regex: `/^[\s\S]*$/.test(obj)` (this approach is not as efficient as the others)
* Using a library like Lodash's `isArray` function

These alternatives may have similar pros and cons to the approaches compared in the benchmark, but they are not part of the original implementation.

Related benchmarks:

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

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):