Benchmark: Alternate Array.isArray vs instanceof with extra nonsense

Script Preparation code:

var c = 0, a = Array(10).fill().map((el,i) => i);var c = 0, a = Array(10).fill().map((el,i) => i);

Tests:

Instanceof if
if(a instanceof Array) ++c;
isArray if
if(Array.isArray(a)) ++c;
Length if
if(a.length > -1) ++c;
Length if undef
if(a.length !== undefined) ++c;
Map if
if(a.map) ++c;
Ctor check
if(a.constructor === Array) ++c;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Instanceof if
isArray if
Length if
Length if undef
Map if
Ctor check

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36

Browser/OS: Chrome 107 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Instanceof if	5494472.0 Ops/sec
isArray if	5395938.0 Ops/sec
Length if	8324989.5 Ops/sec
Length if undef	5432592.0 Ops/sec
Map if	8486778.0 Ops/sec
Ctor check	5373641.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview**

MeasureThat.net is a platform that allows users to create and run JavaScript microbenchmarks. The provided benchmark definition json represents the test case, which compares various approaches for checking if an array-like object is actually an array.

**Benchmark Definition**

The benchmark definition json has three main sections:

1. **Script Preparation Code**: This code sets up two identical arrays `a` using the `Array(10).fill().map((el,i) => i)` method, which creates a new array with 10 elements that increment by index.
2. **Html Preparation Code**: There is no HTML preparation code provided.
3. **Benchmark Definition**: The benchmark definition specifies six test cases:

* `if(a instanceof Array) ++c;`
* `if(Array.isArray(a)) ++c;`
* `if(a.length > -1) ++c;`
* `if(a.length !== undefined) ++c;`
* `if(a.map) ++c;`
* `if(a.constructor === Array) ++c;`

Each test case is a simple if-statement that checks the condition and increments a counter variable `c` if true.

**Options Compared**

The benchmark compares six different approaches to check if an array-like object is actually an array:

1. **`instanceof`**: Checks if the object is an instance of the Array constructor.
2. **`Array.isArray()`**: A method provided by the Array prototype that checks if an object is an array.
3. **Length Check**: Checks if the length property of the object is greater than -1, which is a common heuristic for checking if an object is an array.
4. **Undefined Length Check**: Similar to the previous approach, but also checks if the length property is not undefined.
5. **Map Check**: Checks if the `map()` method is defined on the object, which is another common way to check if an object is an array-like object.
6. **Constructor Check**: Checks if the constructor property of the object is equal to the Array constructor.

**Pros and Cons**

Here's a brief pros and cons summary for each approach:

1. **`instanceof`**:
	* Pros: Simple and reliable, but can be slower due to the overhead of the constructor lookup.
	* Cons: May not work correctly for certain types of objects (e.g., arrays created with `Array.from()`).
2. **`Array.isArray()`**:
	* Pros: Fast and widely supported, but may not work correctly for certain types of objects (e.g., non-array-like objects with a defined length property).
	* Cons: May be slower than the other approaches due to the method call overhead.
3. **Length Check**: Quick and simple, but may not be accurate for all cases (e.g., if the object's length is -1 or NaN).
4. **Undefined Length Check**:
	* Similar pros and cons as the previous approach, with an added layer of complexity due to the additional check.
5. **Map Check**: Fast and reliable, but may not work correctly for certain types of objects (e.g., if the `map()` method is defined but returns a non-array value).
6. **Constructor Check**:
	* Pros: Simple and reliable, with good performance characteristics.
	* Cons: May be slower than some other approaches due to the constructor lookup overhead.

**Other Considerations**

The benchmark also considers various factors such as:

* Device platform and operating system
* Browser version and rendering engine
* Number of executions per second

These factors can affect the results and provide a more accurate representation of real-world performance characteristics.

**Alternatives**

Some alternative approaches to checking if an array-like object is actually an array include:

1. Using `Object.is(a, Array)` (if supported by the browser)
2. Checking for specific properties or methods that are unique to arrays
3. Using a library like Lodash's `isArrayLike()` function

However, these alternatives may not be as widely supported or perform as well as the approaches compared in this benchmark.

Related benchmarks:

Alternate Array.isArray vs instanceof with extra nonsense (version: 0)

Comparing performance of: Instanceof if vs isArray if vs Length if vs Length if undef vs Map if vs Ctor check

Created: 2 years ago by: Guest

Jump to the latest result

Instanceof if

isArray if

Length if

Length if undef

Map if

Ctor check

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