Benchmark: String Union Predicates

Script Preparation code:

var roles = ['owner', 'writer', 'reader', 'freeBusyReader'];
var roleSet = new Set(roles);


function isRoleA(str) {
   return roles.includes(str);
}

function isRoleS(str) {
   return roleSet.has(str);
}

function isRoleSw(str) {
   switch (str) {
      case 'owner':
      case 'writer':
      case 'reader':
      case 'freeBusyReader':
         return true;
      default:
         return false;
   };
}


var testees = ['owner', 'writer', 'reader', 'freeBusyReader', 'ower', 'wrer', 'reer', 'freeBueader',]

Tests:

Array.includes
const rA = testees.map(s => isRoleA(s));
Set.has
const rS = testees.map(s => isRoleS(s));
switch
const rSw = testees.map(s => isRoleSw(s));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.includes
Set.has
switch

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 94 on Windows

View result in a separate tab

Test name	Executions per second
Array.includes	597597.2 Ops/sec
Set.has	506829.9 Ops/sec
switch	1168141.9 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring JavaScript performance is a crucial aspect of web development, and platforms like MeasureThat.net provide a valuable resource for benchmarking. Let's break down the provided JSON and explain what's tested.

**Benchmark Definition**

The benchmark definition contains information about the test case. It appears to be testing three different approaches:

1. `Array.includes`: This method checks if an element exists in an array.
2. `Set.has`: This method checks if a value exists in a Set data structure.
3. `switch` statement: A control flow construct that executes different blocks of code based on the value of an expression.

**Options Compared**

In this benchmark, two options are compared:

1. **Array-based approach**: Using the `includes()` method to check for membership in an array.
2. **Set-based approach**: Using a Set data structure (`Set.has()`) to quickly check for presence of values.

**Pros and Cons**

Here's a brief analysis of each option:

* **Array.includes**:
	+ Pros: Widely supported, easy to implement, and can be optimized using techniques like caching or precomputation.
	+ Cons: Can be slower than Set-based approaches for large datasets due to the overhead of searching in an array.
* **Set.has**:
	+ Pros: Generally faster than Array.includes, especially for large datasets. Sets provide O(1) lookup times, making them suitable for performance-critical applications.
	+ Cons: May not be as widely supported or familiar to developers, requiring more expertise to implement correctly.

**Special Considerations**

None mentioned in the provided JSON.

**Library and Purpose**

The `Set` data structure is a built-in JavaScript API. It's used to efficiently store unique values, providing fast membership testing (O(1) lookup).

Now, let's look at some other alternatives:

* **Regular expressions**: Some developers might use regular expressions to implement Set-like behavior for membership testing.
* **Custom implementations**: Depending on the specific requirements and constraints of the project, developers might choose to implement their own custom algorithms or data structures.

**Additional Notes**

In general, when dealing with performance-critical JavaScript code, it's essential to consider factors like:

* Caching: Store intermediate results to avoid repeated computations.
* Memoization: Store function results to avoid redundant calculations.
* Parallelism: Utilize multiple CPU cores or worker threads to execute tasks concurrently.

Keep in mind that the best approach often depends on the specific requirements of your project, and experimentation with different techniques can help you find the most efficient solution.

Related benchmarks:

String Union Predicates (version: 0)

Comparing performance of: Array.includes vs Set.has vs switch

Created: 3 years ago by: Guest

Jump to the latest result

Array.includes

Set.has

switch

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