Benchmark: pageid regex vs indexOf - shifted match

Tests:

indexOf
let placeholders = [ 'country_adwad', 'country_adwad?adwas=true', 'country_adwad#anchor', 'country_adwad?adwas=true#anchor' ]; placeholders.forEach((placeholder) => { var placeholderLength = placeholder.length; var endPageId = placeholder.indexOf('?') !== -1 ? placeholder.indexOf('?') : placeholder.indexOf('#') !== -1 ? placeholder.indexOf('#') : placeholderLength; console.log(placeholder.substring(0, endPageId), placeholder.substring(endPageId, placeholderLength)); });
regex
let placeholders = [ 'country_adwad', 'country_adwad?adwas=true', 'country_adwad#anchor', 'country_adwad?adwas=true#anchor' ]; placeholders.forEach((item) => { const regexp = /^([a-zA-Z-_]+)([?#].*)?/; let match = item.match(regexp); let pageID = match[1]; let queryString = match[2] !== undefined ? match[2] : ''; console.log(pageID, queryString); });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf
regex

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.

Measuring That.net is an interesting tool for comparing performance of different approaches in JavaScript.

The provided benchmark definition JSON represents two test cases: `indexOf` and `regex`. Both test cases use the same script preparation code, which creates an array of strings with various formats.

**Test Case 1: indexOf**

In this test case, the script uses the `indexOf()` method to find the index of the first occurrence of a specific character in each string. The character is determined by the format of the string. For example, if the string ends with '?', the character is '?', otherwise it's '#'. The script then extracts two substrings from the original string: one up to the found index and another from the found index to the end of the string.

**Test Case 2: regex**

In this test case, the script uses a regular expression (`/^[a-zA-Z-_]+(#[?#].*)?$/`) to match the first part of each string (up to '#') and an optional second part (after '#'). The script then extracts two substrings from the matched strings: one up to the position where '#' was found, and another from the found position to the end of the string.

**Comparison**

The `indexOf` method is a built-in JavaScript function that performs a linear search for the specified character. It's simple but relatively slow compared to regular expressions.

Regular expressions, on the other hand, are powerful patterns that can match complex patterns. However, they also come with a performance overhead due to the complexity of parsing and executing the pattern.

**Pros and Cons**

* `indexOf`:
	+ Pros: Fast, straightforward, and easy to implement.
	+ Cons: Linear search can be slow for large strings.
* Regular expressions:
	+ Pros: Powerful, flexible, and suitable for complex patterns.
	+ Cons: Slower due to the complexity of parsing and executing the pattern.

**Library Used**

Neither of these test cases uses an external library. The `indexOf` method is a built-in JavaScript function, while regular expressions are implemented in the JavaScript engine itself.

**Special JS Feature or Syntax**

There's no special feature or syntax being tested here; it's just plain JavaScript.

**Other Considerations**

When writing performance benchmarks like these, it's essential to consider factors such as:

* Input data: The size and complexity of the input data can significantly impact performance.
* Browser versions and platforms: Different browsers may have varying levels of support for certain features or optimizations.
* Algorithmic differences: Even minor variations in algorithm implementation can lead to significant performance differences.

**Alternatives**

If you're looking for alternatives to measuring JavaScript performance, consider using:

* Google's V8 benchmark suite
* Mozilla's SpiderMonkey benchmark suite
* WebAssembly benchmarks (for comparison with compiled languages)
* Node.js benchmarks (for comparison with the JavaScript runtime)

Keep in mind that these are just a few examples, and there are many other tools and resources available for measuring performance in JavaScript.

Related benchmarks:

pageid regex vs indexOf - shifted match (version: 0)

Comparing performance of: indexOf vs regex

Created: 2 years ago by: Guest

Jump to the latest result

indexOf

regex

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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