Benchmark: Alternate Array.isArray vs instanceof with 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;
Instanceof npe
c += Number(a instanceof Array);
Instanceof mpe
c += (0 + (a instanceof Array));
isArray if
if(Array.isArray(a)) ++c;
isArray npe
c += Number(Array.isArray(a))
isArray mpe
c += (0 + (Array.isArray(a)));
Length if
if(a.length > -1) ++c;
Length npe
c += Number(a.length > -1);
Length mpe
c += (0 + (a.length > -1));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Instanceof if
Instanceof npe
Instanceof mpe
isArray if
isArray npe
isArray mpe
Length if
Length npe
Length mpe

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmarking test case on the MeasureThat.net website. The benchmark compares different ways of checking if an array is valid or not using the `Array.isArray()` method and the `instanceof` operator.

**Options Compared**

1. **Instanceof with Number**: This option converts the result of `a instanceof Array` to a number (0 or 1) before adding it to `c`. The idea is that `instanceof` will return true for arrays, but not for non-array values, so this conversion allows for easy addition.
2. **Instanceof without Number**: Similar to the previous option, but without converting the result to a number.
3. **Instanceof with parentheses**: This option wraps the expression `(a instanceof Array)` in parentheses before adding it to `c`. The idea is that this prevents short-circuit evaluation and ensures that the check is always performed regardless of the value of `a`.
4. **isArray using if statement**: This option uses an if statement to check if `a` is an array, incrementing `c` only if it is.
5. **isArray without if statement**: Similar to the previous option, but without the if statement.
6. **Length checking (a.length > -1)**: This option checks if the length of `a` is greater than -1. Since arrays always have a valid length (or -1 for empty arrays), this effectively checks if `a` is an array.

**Pros and Cons**

*   **Instanceof with Number**: Pros: simple, efficient; Cons: assumes that `instanceof` will always return true for arrays, which can lead to false positives.
*   **Instanceof without Number**: Pros: similar to the previous option but avoids assuming a specific behavior for non-array values; Cons: still assumes that `instanceof` will always return true for arrays.
*   **Instanceof with parentheses**: Pros: prevents short-circuit evaluation and ensures consistent behavior regardless of the value of `a`; Cons: slightly more complex, may be slower due to the additional operation.
*   **isArray using if statement**: Pros: clear and unambiguous code; Cons: potentially slower due to the extra overhead of the if statement.
*   **Length checking (a.length > -1)**: Pros: simple, efficient; Cons: assumes that arrays always have a valid length, which can lead to false negatives for non-array values.

**Library Usage**

The `Array.isArray()` method is a built-in JavaScript method that checks if an object is an array. It is used in several test cases to check if `a` is an array.

**Special JS Features/Syntax**

None mentioned in the provided benchmark definition. However, it's worth noting that some older browsers may not support `instanceof` or `Array.isArray()` for certain types of objects (e.g., arrays of custom objects).

**Benchmark Results**

The benchmark results show that:

*   **Instanceof with Number** is generally faster than the other options but can produce false positives.
*   **Instanceof without Number** and **Instanceof with parentheses** are similar in performance to each other but slower than the `Array.isArray()` method.
*   **isArray using if statement** is the slowest option due to the extra overhead of the if statement.
*   **Length checking (a.length > -1)** is generally faster than the `instanceof` options but can produce false negatives.

Overall, the choice of which option to use depends on performance requirements and potential sources of error.

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 12; DE2118) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 105 on Android

View result in a separate tab

Test name	Executions per second
Instanceof if	727988.6 Ops/sec
Instanceof npe	466704.2 Ops/sec
Instanceof mpe	712120.8 Ops/sec
isArray if	670750.4 Ops/sec
isArray npe	545159.4 Ops/sec
isArray mpe	613199.4 Ops/sec
Length if	1166748.8 Ops/sec
Length npe	730092.0 Ops/sec
Length mpe	1191733.0 Ops/sec

Related benchmarks:

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

Comparing performance of: Instanceof if vs Instanceof npe vs Instanceof mpe vs isArray if vs isArray npe vs isArray mpe vs Length if vs Length npe vs Length mpe

Created: 2 years ago by: Guest

Jump to the latest result

Instanceof if

Instanceof npe

Instanceof mpe

isArray if

isArray npe

isArray mpe

Length if

Length npe

Length mpe

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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