Benchmark: var is a non-empty array

var is a non-empty array (version: 0)

Micro-benchmark various method of checking for non-empty array on arbitrary variable

Comparing performance of: IsArray (array) vs IsArray (null) vs typecheck (nullable dot) (array) vs typecheck (nullable dot) (null) vs manual check cond (array) vs manual check cond (null) vs typeof obj + length (array) vs typeof obj + length (null)

Created: 2 years ago by: Guest

Jump to the latest result

Script Preparation code:

var arr = [1,2,3];
var notArr = null;

Tests:

IsArray (array)
Array.isArray(arr) && arr.length > 0
IsArray (null)
Array.isArray(notArr) && notArr.length > 0
typecheck (nullable dot) (array)
arr?.length > 0
typecheck (nullable dot) (null)
notArr?.length > 0
manual check cond (array)
arr !== null && arr !== undefined && arr.length > 0
manual check cond (null)
notArr !== null && notArr !== undefined && notArr.length > 0
typeof obj + length (array)
typeof arr === 'object' && arr !== null && arr.length > 0
typeof obj + length (null)
typeof notArr === 'object' && notArr !== null && notArr.length > 0

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
IsArray (array)
IsArray (null)
typecheck (nullable dot) (array)
typecheck (nullable dot) (null)
manual check cond (array)
manual check cond (null)
typeof obj + length (array)
typeof obj + length (null)

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark is designed to measure the performance of different approaches for checking if an array or null value exists in JavaScript. The test cases are comparing various methods, including:

1. `Array.isArray()` with conditional checks
2. Nullish coalescing operator (`?.`) with conditional checks
3. Manual checks using `!==` and type checks

**What's being tested**

For each test case, the following values are being checked:

* `arr`: a non-empty array
* `notArr`: null

The benchmark is measuring the performance of each approach in terms of execution speed.

**Approaches and their pros/cons**

1. **Array.isArray() with conditional checks**
	* Pros: straightforward, widely supported
	* Cons: slower than other methods due to conditional check
2. **Nullish coalescing operator (`?.`) with conditional checks**
	* Pros: concise, efficient (faster than Array.isArray())
	* Cons: requires modern JavaScript version support and understanding of nullish coalescing
3. **Manual checks using `!==` and type checks**
	* Pros: control over checks, can be optimized for performance
	* Cons: more verbose, may require additional computations

**Library usage**

The benchmark uses the `Array.isArray()` function from the JavaScript standard library.

**Special JS feature or syntax**

None mentioned in this explanation. The nullish coalescing operator (`?.`) is used, which is a modern JavaScript feature introduced in ECMAScript 2020 (ES10).

**Other alternatives**

Some alternative approaches for checking if an array or null value exists might include:

* Using `typeof` with `object` and type checks
* Using a library like Lodash's `_.isArray()` function
* Implementing custom checks using bitwise operations

However, these alternatives are not part of the benchmarked code.

Related benchmarks: