Benchmark: Parsing window.location.search to object

Script Preparation code:

var search = "?test=test2&test3=test4&test5=test6";
var regex = /[&\?]([^=]+)=([^&]+)/g;

Tests:

Double splitting
var params = {}; var query = search.substring(1); var paramStrs = query.split('&'); for (paramStr of paramStrs) { var pair = paramStr.split('='); params[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]); }
Regex mapping
var params = Object.fromEntries(new Map(Array.from(search.matchAll(regex)).map(match => [decodeURIComponent(match[1]), decodeURIComponent(match[2])])));
Regex looping
var params = {}; while((param = regex.exec(search)) !== null) { params[decodeURIComponent(param[1])] = decodeURIComponent(param[2]); }
Regex iterator
var params = {}; var regexMatches = search.matchAll(regex); while(!(current = regexMatches.next()).done) { var param = current.value; params[decodeURIComponent(param[1])] = decodeURIComponent(param[2]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Double splitting
Regex mapping
Regex looping
Regex iterator

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested.

**Benchmark Definition**

The benchmark measures how fast JavaScript can parse `window.location.search` into an object. This is a common use case in web development, as it allows you to extract query parameters from URLs.

**Script Preparation Code**

The script preparation code defines two variables:

* `search`: a sample URL with query parameters (`?test=test2&test3=test4&test5=test6`)
* `regex`: a regular expression pattern to match the query parameter pairs (`[&\\?]([^=]+)=([^&]+)/g`)

**Html Preparation Code**

There is no HTML preparation code provided, which means that this benchmark only tests JavaScript performance.

**Test Cases**

The benchmark consists of four individual test cases, each measuring how fast a different approach can parse `window.location.search` into an object. The approaches are:

1. **Double splitting**: This method involves:
	* Substring the URL to extract the query string (`search.substring(1)`)
	* Split the query string into parameter pairs using the `&` character (`query.split('&')`)
	* Iterate through each pair, split it further using the `=` character (`pair.split('=')`) and create an object with the decoded key-value pairs (`params[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1])`)
2. **Regex mapping**: This method uses a regular expression pattern to extract the query parameter pairs:
	* Create an array of matches using the `regex` pattern on the `search` string (`search.matchAll(regex)`)
	* Use `Object.fromEntries()` to create an object from the match array (with key-value pairs as tuples)
3. **Regex looping**: This method also uses a regular expression pattern, but with a while loop:
	* Execute the `regex` pattern on the `search` string until there are no more matches (`while((param = regex.exec(search)) !== null)`)
	* Extract the query parameter pairs from each match, decode their keys and values, and create an object (`params[decodeURIComponent(param[1])] = decodeURIComponent(param[2])`)
4. **Regex iterator**: This method uses a regular expression pattern with an iterator:
	* Create an array of matches using the `regex` pattern on the `search` string (`search.matchAll(regex)`)
	* Use a while loop to iterate through the match array, extracting query parameter pairs and creating an object (`params[decodeURIComponent(param[1])] = decodeURIComponent(param[2])`)

**Pros and Cons**

Here's a brief summary of each approach:

* **Double splitting**: Pros: simple, easy to implement. Cons: may be slower due to string manipulation.
* **Regex mapping**: Pros: efficient, uses built-in `Object.fromEntries()` function. Cons: may be less intuitive for those unfamiliar with regex patterns.
* **Regex looping**: Pros: can be faster since it avoids creating unnecessary objects. Cons: more complex, error-prone.
* **Regex iterator**: Pros: similar to regex mapping, but with an iterator. Cons: may be slower due to the overhead of iterating over matches.

**Libraries and Special Features**

None of these test cases explicitly use a library or special JavaScript feature (e.g., async/await, modern arrow functions).

**Alternatives**

Other approaches to parsing `window.location.search` might include:

* Using a dedicated query string parsing library
* Implementing a custom parser using a different algorithm or data structure
* Utilizing browser-specific features, such as Web API's URL class or String.prototype.split()

Keep in mind that this benchmark primarily tests the performance of each approach, so any additional considerations would depend on specific use cases and requirements.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36

Browser/OS: Chrome 105 on Windows

View result in a separate tab

Test name	Executions per second
Double splitting	258721.2 Ops/sec
Regex mapping	257507.3 Ops/sec
Regex looping	215253.3 Ops/sec
Regex iterator	269473.2 Ops/sec

Related benchmarks:

Parsing window.location.search to object (version: 6)

Finding the fastest way to parse window.location.search.

Comparing performance of: Double splitting vs Regex mapping vs Regex looping vs Regex iterator

Created: 2 years ago by: Registered User

Jump to the latest result

Double splitting

Regex mapping

Regex looping

Regex iterator

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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