Benchmark: EGO String removal

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/url-parse@1.5.3/index.js"></script>

Script Preparation code:

var strIn = 'https://site.com/?this=a+test&that=just+it#home';
var strOut = '';
var regex = /\?.*$/;
var regex2 = /#.*$/;

var regexAll = /(\?.*|#.*)$/;

Tests:

Multiple Regex replaces
strOut = strIn.replace(regex, '').replace(regex2, '');
indexOf replace
var idx = strIn.indexOf('?'); if (idx >= 0) { strOut = strIn.slice(0, idx); } var idx2 = strIn.indexOf('#'); if (idx2 >= 0) { strOut = strIn.slice(0, idx2); }
substring replace
var idx = strIn.indexOf('?'); if (idx >= 0) { strOut = strIn.substring(0, idx); } var idx2 = strIn.indexOf('?'); if (idx2 >= 0) { strOut = strIn.substring(0, idx2); }
Regex with OR
strOut = strIn.replace(regexAll, '');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Multiple Regex replaces
indexOf replace
substring replace
Regex with OR

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark tests the performance of different approaches for removing URL parameters from a string in JavaScript. The test cases evaluate the speed and efficiency of various methods, including regular expression replacements, string slicing, and substring extraction.

**Benchmark Definition JSON Analysis**

The benchmark definition JSON contains information about the test case:

* `Name`: "EGO String removal"
* `Description`: null
* `Script Preparation Code`: This code sets up variables for the input string (`strIn`), output string (`strOut`), and regular expression patterns (`regex`, `regex2`) that will be used to remove URL parameters.
* `Html Preparation Code`: This code includes a script tag to load the `url-parse` library, which is used to parse URLs and extract query parameters.

**Individual Test Cases**

Each test case defines a specific benchmarking scenario:

1. **Multiple Regex Replaces**: Tests replacing multiple regular expression patterns (`regex` and `regex2`) with an empty string.
2. **IndexOf Replace**: Tests using the `indexOf()` method to find the index of a query parameter in the input string, and then removing it by slicing the string up to that index.
3. **Substring Replace**: Similar to the previous test case, but uses the `substring()` method instead of `slice()`.
4. **Regex with OR**: Tests replacing a single regular expression pattern (`regexAll`) that matches either query parameters or fragment identifiers.

**Library: url-parse**

The `url-parse` library is used to parse URLs and extract query parameters. Its purpose is to provide a convenient way to work with URL data in JavaScript.

**Special JS Feature/Syntax: None**

None of the test cases use any special JavaScript features or syntax that would require additional explanation.

**Pros and Cons of Different Approaches**

1. **Regular Expression Replacements**: Pros:
	* Efficient for removing multiple patterns.
	* Can be highly optimized using flags and anchors.
	* Cons:
		+ May be slower than other methods due to regex compilation.
2. **IndexOf Replace**: Pros:
	+ Simple and straightforward implementation.
	+ Fast since it only checks for the presence of a query parameter.
Cons:
	+ Slower than regular expression replacements for multiple patterns.
3. **Substring Replace**: Similar pros and cons as `IndexOf Replace`.
4. **Regex with OR**: Pros:
	+ Convenient way to remove both query parameters and fragment identifiers.
Cons:
	+ May be slower than other methods due to regex compilation.

**Other Alternatives**

1. **Using a URL parsing library (e.g., URL.js)**: These libraries provide an efficient way to work with URLs, but may introduce additional dependencies.
2. **Using a string manipulation function (e.g., `String.prototype.replace()`) with no regex**: This approach can be faster since it avoids regex compilation, but may not be as flexible for removing multiple patterns.

The benchmark results show that the `IndexOf Replace` and `Substring Replace` methods are generally slower than regular expression replacements, while the `Regex with OR` method performs reasonably well. The choice of approach depends on the specific requirements of the use case.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.131 Safari/537.36

Browser/OS: Chrome 92 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Regex replace	2611950.8 Ops/sec
indexOf replace	3412674.2 Ops/sec
substring replace	3324783.0 Ops/sec

Related benchmarks:

EGO String removal (version: 1)

Comparing performance of: Multiple Regex replaces vs indexOf replace vs substring replace vs Regex with OR

Created: 3 years ago by: Registered User

Jump to the latest result

Multiple Regex replaces

indexOf replace

substring replace

Regex with OR

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