Benchmark: Regex vs startswith and slice

Script Preparation code:

window.idregex = /^(?<type>investigation|surface|shared)(?<id>.*)$/
window.str = 'shared:dfhalsdkfjhasldfiuyo324987';

Tests:

Regex
const match = str.match(idregex) const type = match?.groups.type; const id = match?.groups.id
starts with and slice
const type = 'shared'; str.startsWith('investigations') str.startsWith('surfaces') str.startsWith(type) const id = str.slice('shared'.length)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Regex
starts with and slice

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 2 days ago):

LLMs can make mistakes. Check important info.

Let's break down what is being tested in this benchmark.

**Benchmark Definition**

The benchmark is testing two different approaches to perform a common task: extracting the `type` and `id` from a string using either a regular expression or by utilizing the `startsWith` method and slicing.

The script preparation code defines two variables:

* `window.idregex`: a regular expression pattern that matches strings in the format "investigation|surface|shared" followed by an ID ( captured groups: `type` and `id`)
* `window.str`: a test string with the value "shared:dfhalsdkfjhasldfiuyo324987"

**Test Cases**

There are two individual test cases:

1. **Regex**: This test case uses the regular expression pattern defined in the script preparation code to extract the `type` and `id` from the `window.str`. The benchmark measures how many times this code executes per second.
2. **starts with and slice**: This test case uses the `startsWith` method and slicing to achieve the same result as the Regex approach. It checks if the string starts with "investigations", "surfaces", or the value of the `type` variable, and then slices the string by the length of "shared" to extract the ID.

**Options Compared**

The benchmark is comparing two approaches:

* **Regular Expression (Regex)**: Using a regular expression pattern to extract the data from the string.
* **startsWith and Slice**: Utilizing the `startsWith` method and slicing to achieve the same result as the Regex approach.

**Pros and Cons of Each Approach**

* **Regex**:
	+ Pros:
		- Flexible and powerful for pattern matching
		- Can be used to extract data from strings with varying formats
	+ Cons:
		- Can be slower due to the complexity of regular expressions
		- May have performance issues if not implemented correctly
* **startsWith and Slice**:
	+ Pros:
		- Faster execution times due to fewer operations required
		- Easier to implement for simple cases
	+ Cons:
		- Less flexible and may not work with all string formats

**Library Used**

None. The benchmark only uses built-in JavaScript methods (regex, `startsWith`, slicing) without importing any external libraries.

**Special JS Feature or Syntax**

The test case uses the optional chaining operator (`?.`) to access the `groups` property of the match object without throwing an error if it doesn't exist.

**Other Considerations**

* The benchmark measures the execution time per second, which can help identify performance differences between the two approaches.
* The results will likely vary depending on the input data, string length, and platform-specific optimizations.

**Alternatives**

Other alternatives to these approaches could include:

* Utilizing a library like `lodash` or `underscore` for string manipulation
* Using a dedicated parsing library for complex data formats (e.g., JSON)
* Employing more advanced techniques like array methods (e.g., `filter()`, `map()`) or functional programming concepts

Keep in mind that the choice of approach depends on the specific requirements and constraints of the project.

Latest run results:

Run details: (Test run date: 7 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15

Browser/OS: Safari 18 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Regex	5807172.0 Ops/sec
starts with and slice	5938906.0 Ops/sec

Related benchmarks:

Regex vs startswith and slice (version: 0)

Comparing performance of: Regex vs starts with and slice

Created: 12 days ago by: Registered User

Jump to the latest result

Regex

starts with and slice

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 2 days ago):