Benchmark: chain of or equals vs Array.includes

Script Preparation code:

var x = 3;
var list = [undefined, NaN, null, ''];

Tests:

Array.includes
[undefined, NaN, null, ''].includes(x)
Or chain
x === undefined || Number.isNaN(x) || x === null || x === ''
Or chain (witch cheap 'undefined' check)
typeof x === 'undefined' || Number.isNaN(x) || x === null || x === ''
Array.includes with predefined list
list.includes(x)
Array.includes with predefined list (witch cheap 'undefined' check)
typeof x === 'undefined' || list.includes(x)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.includes
Or chain
Or chain (witch cheap 'undefined' check)
Array.includes with predefined list
Array.includes with predefined list (witch cheap 'undefined' check)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36

Browser/OS: Chrome 109 on Windows

View result in a separate tab

Test name	Executions per second
wUmrLVWz	1.0 Ops/sec
wUmrLVWz	1.0 Ops/sec
wUmrLVWz	1.0 Ops/sec
wUmrLVWz	1.0 Ops/sec
wUmrLVWz	1.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided JSON represents a JavaScript microbenchmark test case, specifically designed to compare the performance of different approaches for checking if a value is `undefined`, `NaN` (Not a Number), or an empty string.

**Test Case Options Compared**

There are four options compared:

1. **Array.includes**: This method checks if the specified value exists in the provided array.
2. **Or chain**: This approach uses a series of OR (`||`) operators to check for the presence of `undefined`, `NaN`, or an empty string.
3. **Or chain (with cheap 'undefined' check)**: A variation of the previous approach that uses the `typeof` operator to perform a "cheap" check for `undefined`.
4. **Array.includes with predefined list**: This option uses the same array as in Option 2 but predefines it, allowing for a direct comparison.
5. **Array.includes with predefined list (with cheap 'undefined' check)**: A variation of Option 4 that uses the `typeof` operator to perform a "cheap" check for `undefined`.

**Pros and Cons**

Here's a brief summary of each option:

1. **Array.includes**: Fastest approach, as it utilizes the optimized array search algorithm.
	* Pros: Quick performance
	* Cons: Requires an additional array lookup, which can be slower than direct checks
2. **Or chain**: A straightforward approach that uses simple OR operators to check for multiple values.
	* Pros: Easy to understand and implement
	* Cons: Can lead to longer execution times due to the overhead of repeated checks
3. **Or chain (with cheap 'undefined' check)**: Optimizes the `undefined` check by using `typeof`.
	* Pros: Reduces unnecessary checks, improving performance
	* Cons: Still performs multiple checks, which can be slower than a single `Array.includes` call
4. **Array.includes with predefined list**: Utilizes the optimized array search algorithm.
	* Pros: Quick performance and readability
	* Cons: Requires an additional array lookup, which can slow down execution
5. **Array.includes with predefined list (with cheap 'undefined' check)**: Combines the benefits of predefining the array and optimizing the `undefined` check.
	* Pros: Balanced performance and readability
	* Cons: Still requires an additional array lookup

**Library and Special JS Features**

No external libraries are used in this benchmark. However, it does utilize a feature specific to JavaScript 12+ versions: **`typeof x === 'undefined'`**, which is a more concise way of checking if `x` is `undefined`.

**Other Alternatives**

If you need alternative approaches, consider:

1. Using `Object.prototype.hasOwnProperty.call()` or similar methods for array checks.
2. Implementing custom binary search algorithms for arrays.
3. Utilizing specialized libraries like `fast-assert` or `benchmark` for benchmarking.

Keep in mind that these alternatives may have different performance characteristics and trade-offs.

Related benchmarks:

chain of or equals vs Array.includes (version: 0)

What works best when value misses all the conditions.

Comparing performance of: Array.includes vs Or chain vs Or chain (witch cheap 'undefined' check) vs Array.includes with predefined list vs Array.includes with predefined list (witch cheap 'undefined' check)

Created: one year ago by: Guest

Jump to the latest result

Array.includes

Or chain

Or chain (witch cheap 'undefined' check)

Array.includes with predefined list

Array.includes with predefined list (witch cheap 'undefined' 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):