Benchmark: or vs array vs set

Tests:

or
function is(string) { return string === 'a' || string === 'b' || string == 'c' || string === 'd' || string === 'e' || string === 'f' } is('d'); is('z');
arr
function is(string) { return ['a', 'b', 'c', 'd', 'e', 'f'].includes(string) } is('d'), is('z')
set
function is(string) { return new Set(['a', 'b', 'c', 'd', 'e', 'f']).has(string) } is('d'), is('z')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
or
arr
set

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 98 on Linux

View result in a separate tab

Test name	Executions per second
or	1222124288.0 Ops/sec
arr	1223841664.0 Ops/sec
set	2112825.5 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to explain what's being tested in the provided JSON benchmark.

**Benchmark Overview**

The benchmark is designed to compare the performance of three different approaches: using an `or` statement, an array (`includes()` method), and a Set data structure. The goal is to measure which approach performs best for a specific use case: checking if a string matches one of six predefined values ("a" to "f").

**Options Compared**

The benchmark compares the performance of three options:

1. **Or Statement**: A simple `or` statement with multiple conditions.
2. **Array (`includes()` method)**: Using an array and the `includes()` method to check if a string is present in the array.
3. **Set Data Structure**: Using a Set data structure and the `has()` method to check if a value exists in the set.

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

1. **Or Statement**:
	* Pros: Simple, easy to understand, and fast.
	* Cons: Can be brittle (e.g., prone to errors due to typos or unexpected values).
2. **Array (`includes()` method)**:
	* Pros: Fast, modern, and widely supported.
	* Cons: May have slower performance for small arrays or when searching for a specific value.
3. **Set Data Structure**:
	* Pros: Fast, efficient, and suitable for large datasets.
	* Cons: Requires an additional data structure (the Set), which may be overkill for this specific use case.

**Library Used**

In the benchmark code, there is no explicit library usage mentioned, but it's likely that the `includes()` method relies on a built-in JavaScript function or a polyfill to ensure compatibility across different browsers and environments.

**Special JS Feature/Syntax**

There is no special JS feature or syntax used in this benchmark. The focus is on comparing the performance of three different approaches rather than showcasing advanced features.

**Other Alternatives**

If you were to optimize this approach further, some alternative methods could be explored:

* Using a switch statement instead of an `or` statement for better readability and maintainability.
* Creating a regex pattern to match any of the predefined values ("a" to "f") for better performance.
* Utilizing bitwise operations (e.g., using the `&` operator) to compare individual bits with each value in the Set data structure.

However, these alternatives might not be as straightforward or efficient as the original approach.

Related benchmarks:

or vs array vs set (version: 0)

Comparing performance of: or vs arr vs set

Created: 4 years ago by: Guest

Jump to the latest result

or

arr

set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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