Benchmark: Multiple OR statements vs. Array Index Of.

Script Preparation code:

var array = ['a','b','c'];
var largeArray = ['a','b','c','d','e','f','g'];

Tests:

small array - OR
if(array[0] === 'c' || array[1] === 'c' || array[2] === 'c'){ console.log('found') }
small array - indexOf
if(array.indexOf('c') !== -1){ console.log('found') }
large array - OR
if(largeArray[0] === 'g' || largeArray[1] === 'g' || largeArray[2] === 'g' || largeArray[3] === 'g' || largeArray[4] === 'g' || largeArray[5] === 'g' || largeArray[6] === 'g' || largeArray[7] === 'g'){ console.log('found') }
large array - indexOf
if(largeArray.indexOf('g') !== -1){ console.log('found') }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
small array - OR
small array - indexOf
large array - OR
large array - indexOf

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.114 Safari/537.36

Browser/OS: Chrome 89 on Linux

View result in a separate tab

Test name	Executions per second
small array - OR	39738.8 Ops/sec
small array - indexOf	38165.5 Ops/sec
large array - OR	38013.3 Ops/sec
large array - indexOf	43323.6 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**What is being tested?**

The benchmark measures the performance difference between using multiple `OR` statements versus `indexOf` method to check if a specific value exists in an array.

Specifically, the test cases compare:

1. Multiple `OR` statements (`array[0] === 'c' || array[1] === 'c' || array[2] === 'c'`)
2. `indexOf` method (`array.indexOf('c') !== -1`)

**Options being compared:**

* Multiple `OR` statements
* `indexOf` method

**Pros and Cons of each approach:**

* **Multiple OR statements:**
	+ Pros:
		- Can be more efficient for small arrays, as it avoids the overhead of the `indexOf` method.
		- Easy to implement and understand.
	+ Cons:
		- Can become slow and inefficient for large arrays, as it requires checking every element in the array.
		- Error-prone if not implemented correctly (e.g., missing or mismatched indices).
* **indexOf method:**
	+ Pros:
		- Generally faster and more efficient than multiple `OR` statements for large arrays.
		- More concise and easier to maintain, as it avoids manual index checking.
	+ Cons:
		- Requires the array to be sorted (in ascending order) for optimal performance.
		- Can throw errors if the value is not found in the array.

**Library used:**

* `indexOf` method uses the built-in JavaScript function `Array.indexOf()`, which is implemented by the browser engine (e.g., V8 in Chrome).

**Special JS feature or syntax:**

* The benchmark does not use any special JavaScript features or syntax beyond what is standard for the language.

**Other considerations:**

* The benchmark assumes that the array elements are strings, and only checks for exact string matches.
* There is no consideration for performance variations between different browsers, as the results are consistent across all tested browsers (Chrome 89).

**Alternatives:**

* Other approaches to check if a value exists in an array include:
	+ Using `includes()` method (introduced in ECMAScript 2019): `array.includes('c')`
	+ Using `reduce()` method with a predicate function: `array.reduce((a, b) => a || b === 'c', false)`
	+ Using a custom implementation with a binary search algorithm.

Keep in mind that these alternatives may have different performance characteristics and are not necessarily more efficient than the methods being compared.

Related benchmarks:

Multiple OR statements vs. Array Index Of. (version: 0)

Let's see if multiple OR statements or index Of array is faster.

Comparing performance of: small array - OR vs small array - indexOf vs large array - OR vs large array - indexOf

Created: 3 years ago by: Registered User

Jump to the latest result

small array - OR

small array - indexOf

large array - OR

large array - indexOf

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