Benchmark: regexs vs. loop - MeasureThat.net

HTML Preparation code:

var host = 'api-staging.eurostar.com';

Script Preparation code:

var host = 'api-staging.eurostar.com';

Tests:

regexs
const allowedRedirectHostsRegExp = new RegExp('eurostar.com|localhost', 'i'); allowedRedirectHostsRegExp.test(host);
loop
['eurostar.com', 'localhost'].includes(host);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regexs
loop

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON benchmark data.

**Benchmark Definition**

The website measures the performance of two different approaches to check if a URL is allowed for redirect:

1. **Regex approach**: `const allowedRedirectHostsRegExp = new RegExp('eurostar.com|localhost', 'i');\r\nallowedRedirectHostsRegExp.test(host);`
2. **Loop approach**: `['eurostar.com', 'localhost'].includes(host)`

**Options Compared**

The benchmark compares the performance of these two approaches:

* Regex approach: Using a regular expression to match the allowed hosts.
* Loop approach: Checking if the host is in an array of allowed hosts using the `includes()` method.

**Pros and Cons**

**Regex Approach:**

Pros:

* More concise and expressive
* Can be easily extended to support more complex rules

Cons:

* May be slower due to the overhead of compiling regular expressions
* Can be less readable for developers without experience with regex patterns

**Loop Approach:**

Pros:

* Typically faster since it avoids the overhead of compiling regular expressions
* More readable for developers without experience with regex patterns

Cons:

* Less concise and more verbose than the regex approach
* May require additional maintenance to add or remove allowed hosts from the array.

**Library Used**

In both test cases, no specific library is used. However, it's worth noting that if you were to use a library like `lodash` in the loop approach, it could simplify the code and make it more readable: `_.includes(['eurostar.com', 'localhost'], host)`

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax used in this benchmark. The test cases only use basic JavaScript concepts.

**Other Alternatives**

If you wanted to add additional approaches to the benchmark, here are some alternatives:

* Using a `switch` statement: `switch (host) { case 'eurostar.com': // ... case 'localhost': // ... }`
* Using a `switch` statement with regular expressions: `switch (allowedRedirectHostsRegExp.test(host)) { case true: // ... }`
* Using a more modern approach like template literals or destructuring: `const [host1, host2] = ['eurostar.com', 'localhost']; if (host === host1 || host === host2) { // ... }`

Keep in mind that these alternatives may not be as straightforward or readable as the original loop approach.

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 Edg/109.0.1518.70

Browser/OS: Chrome 109 on Windows

View result in a separate tab

Test name	Executions per second
regexs	1462547.0 Ops/sec
loop	4431636.0 Ops/sec

Related benchmarks:

regexs vs. loop (version: 0)

Comparing performance of: regexs vs loop

Created: one year ago by: Guest

Jump to the latest result

regexs

loop

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