Benchmark: Array isArray vs typeof vs array || []

Script Preparation code:

var test = [1,2,3,4];
var c;

Tests:

typeof
if (typeof test === 'object') { c++; }
isArray
if (Array.isArray(test)) { c++; }
array || []
if (test || []) { c++; }
instanceOf
if (test instanceof Array) { c++; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
typeof
isArray
array \|\| []
instanceOf

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 months ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 18_2_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 18 on iOS 18.2.1

View result in a separate tab

Test name	Executions per second
typeof	151512944.0 Ops/sec
isArray	147435040.0 Ops/sec
array \|\| []	146745568.0 Ops/sec
instanceOf	126509232.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):

LLMs can make mistakes. Check important info.

In the provided benchmark, the performance of different methods for determining whether a variable is an array in JavaScript is tested. Four approaches are compared: `typeof`, `Array.isArray()`, logical OR (`array || []`), and the `instanceof` operator. Each of these methods can determine if the variable `test` is an array, but they achieve this in different ways, with varying implications in terms of performance and correctness.

### Benchmark Options Compared:

1. **`typeof test === 'object'`**
   - **Description**: This method checks if `test` is of type 'object'. Since arrays in JavaScript are technically objects, this will return `true` for arrays.
   - **Pros**: Simple to write and understand.
   - **Cons**: It is not specific to arrays; it will return `true` for any object type, including null and functions. Hence, it can generate false positives.

2. **`Array.isArray(test)`**
   - **Description**: This built-in method specifically checks if `test` is an array.
   - **Pros**: Accurate and avoids the pitfalls of the `typeof` method as it returns `true` only for arrays. It also handles edge cases correctly (e.g., it works across different frames in the browser).
   - **Cons**: Slightly slower than the `typeof` check due to additional internal logic.

3. **`test || []`**
   - **Description**: This logical OR checks if `test` is truthy; if it is, it will return `test`; otherwise, it will return an empty array.
   - **Pros**: Very concise and can be used as a part of a larger expression.
   - **Cons**: Does not correctly determine if `test` is an array. It will return an empty array if `test` is falsy (e.g., `null`, `undefined`, or `0`), leading to potential logical errors if you are trying to verify array status.

4. **`test instanceof Array`**
   - **Description**: This checks if `test` is an instance of the `Array` class.
   - **Pros**: Generally accurate and works well in many scenarios, as it directly checks the prototype chain.
   - **Cons**: May not work correctly with arrays created in different contexts (iframes or web workers), where they might not share the same `Array` constructor.

### Benchmark Results Overview:

The benchmark results provide a performance comparison of these methods, measured in executions per second:

- **`typeof`**: 392,381,952 executions per second (fastest).
- **`array || []`**: 392,112,544 executions per second (very fast).
- **`isArray`**: 164,796,480 executions per second (noticeably slower).
- **`instanceOf`**: 162,369,488 executions per second (slowest among the tested methods).

### Other Considerations:

- **Performance vs Accuracy**: When choosing a method, it is crucial to balance performance with the accuracy of the result. For critical applications where performance is paramount and the context of usage is well understood, faster methods (like `typeof`) might be favored despite their inaccuracies.
  
- **Readability and Maintainability**: Code is often read more times than it is written. Methods like `Array.isArray()` may be less performant but are more readable and provide clearer intent, which can be a significant advantage in long-term code maintenance.

### Alternatives:

Other alternatives for determining whether a variable is an array include:

- **Using `Object.prototype.toString.call(test)`**: This method returns the internal class of the object, which allows a precise check for arrays. It is more verbose but offers robust accuracy.
  
- **Using utility libraries**: Libraries such as Lodash and Underscore provide functions that abstract these checks (like `_.isArray(...)`), providing both ease of use and consistency across different execution contexts.

Each of these methods has its use cases; understanding the pros and cons can guide developers to select the most appropriate one for their specific scenario.

Related benchmarks:

Array isArray vs typeof vs array || [] (version: 1)

Comparing performance of: typeof vs isArray vs array || [] vs instanceOf

Created: 3 months ago by: Guest

Jump to the latest result

typeof

isArray

array || []

instanceOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 3 months ago):