Benchmark: Comparing various way to check if a string is within the values of a typescript enum

Comparing various way to check if a string is within the values of a typescript enum (version: 0)

Given this typescript code // typescript like enum Status { A = 'a', B = 'b', C = 'c', D = 'd' } what is the faster simpler way to know if a string st is within the enum values.

Comparing performance of: compare individual strings vs use a regex vs use a set

Created: 4 years ago by: Guest

Jump to the latest result

Script Preparation code:

var Status;
(function(Status) {
    Status["A"] = "a";
    Status["B"] = "b";
    Status["C"] = "c";
    Status["D"] = "d";
})(Status || (Status = {}));

var st = 'c'

var set1 = new Set([Status.A,Status.B,Status.C]);

Tests:

compare individual strings
return (st === Status.A || st === Status.B || st === Status.C)
use a regex
return (new RegExp(`${Status.A}|${Status.B}|${Status.C}`, 'i')).test(st)
use a set
return set1.has(st)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
compare individual strings
use a regex
use a set

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 JSON and explain what's being tested, the options compared, their pros and cons, and other considerations.

**Benchmark Description**

The benchmark is designed to compare three different approaches to check if a string `st` is within the values of a TypeScript enum `Status`. The enum has four values: `A`, `B`, `C`, and `D`, which are assigned string values "a", "b", "c", and "d" respectively.

**Script Preparation Code**

The script preparation code sets up the `Status` enum and assigns its string values to an object. This is done using a technique called "memoization" or "caching" to avoid recalculating the same values multiple times.

**Individual Test Cases**

There are three test cases:

1. **compare individual strings**: This approach uses a simple if-else statement to check if `st` matches any of the enum values.
2. **use a regex**: This approach uses a regular expression (regex) to match `st` against all the enum values in a case-insensitive manner.
3. **use a set**: This approach uses a Set data structure to store the enum values and then checks if `st` is present in the set.

**Options Compared**

The three test cases compare the following approaches:

* Using individual strings (i.e., comparing `st` against each enum value)
* Using regular expressions
* Using a Set data structure

**Pros and Cons of Each Approach:**

1. **Individual Strings**:
	* Pros: Simple, easy to understand, and widely supported.
	* Cons: May be slower than other approaches for large datasets or complex strings.
2. **Regular Expressions**:
	* Pros: Can match multiple patterns simultaneously, fast, and flexible.
	* Cons: May be slower for simple matching tasks, can be error-prone if not used correctly, and may require additional resources (e.g., Unicode support).
3. **Set**:
	* Pros: Fast, efficient, and suitable for large datasets or complex strings.
	* Cons: Requires the underlying data structure to be ordered, which might not be desirable in all cases.

**Library Used**

The `Set` approach uses a built-in JavaScript `Set` object, which is part of the ECMAScript standard. The `RegExp` approach uses a regular expression engine implemented by the browser or runtime environment.

**Special JS Feature/Syntax**

There are no specific special JavaScript features or syntax used in this benchmark. However, it does utilize some ES6+ features, such as:

* Template literals (`${Status.A}`) for string interpolation
* arrow functions (`(Status) => { ... }`) for concise code

**Other Considerations**

When choosing an approach, consider the following factors:

* Performance: If speed is critical, using a Set or regular expressions might be more suitable.
* Complexity: For simple matching tasks, individual strings might be sufficient.
* Robustness: Regular expressions can be error-prone if not used correctly; therefore, it's essential to carefully consider the trade-offs.

**Alternative Approaches**

Other alternatives that could be considered for this benchmark include:

* Using a data structure like an array or object with keys
* Utilizing the `in` operator or `hasOwnProperty()` method for string matching
* Implementing a custom lookup table or hash function

However, these approaches might not offer significant performance improvements over the existing test cases and may add unnecessary complexity.

Related benchmarks: