Benchmark: Url parameters to object

Script Preparation code:

var query = 'test=1&test=2&alt=test&b=8&c=9&alt=9';

Tests:

Object.entries with URLSearchParams
var result = Object.fromEntries(new URLSearchParams(query));
map reduce
var result = query.split('&') .map(p => p.split('=')) .reduce((obj, pair) => { const [key, value] = pair.map(decodeURIComponent); obj[key] = value; return obj; }, {});
json parse decodeURI
var result = JSON.parse('{"' + decodeURI(query).replace(/"/g, '\\"').replace(/&/g, '","').replace(/=/g,'":"') + '"}')
json parse decodeURIComponent
var result = JSON.parse('{"' + query.replace(/&/g, '","').replace(/=/g,'":"') + '"}', function(key, value) { return key===""?value:decodeURIComponent(value) })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.entries with URLSearchParams
map reduce
json parse decodeURI
json parse decodeURIComponent

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

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

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.entries with URLSearchParams	481354.2 Ops/sec
map reduce	1289953.6 Ops/sec
json parse decodeURI	1187845.0 Ops/sec
json parse decodeURIComponent	640233.2 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided JSON represents a JavaScript microbenchmark test case on MeasureThat.net, which compares the performance of different approaches for parsing URL query strings into JavaScript objects.

**Test Cases**

There are four test cases:

1. **Object.entries with URLSearchParams**: This approach uses the `URLSearchParams` API to parse the URL query string and then converts it to a JavaScript object using `Object.entries`.
2. **Map Reduce**: This approach manually splits the URL query string into key-value pairs, maps each pair to an array of two values (key and value), reduces the array of arrays into a single object.
3. **JSON Parse with decodeURI**: This approach uses `decodeURI` to decode the URL query string and then parses it as JSON using `JSON.parse`.
4. **JSON Parse with decodeURIComponent**: This approach also uses `decodeURI` to decode the URL query string, but wraps the parsing logic in a custom function that decodes the value of each key-value pair.

**Options Compared**

The test case compares the performance of these four approaches:

* Object-oriented programming (OOP) vs. manual iteration
* Using built-in APIs (`URLSearchParams`) vs. manual implementation
* JSON parsing with `decodeURI` vs. using a custom decoding function

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

1. **Object.entries with URLSearchParams**
	* Pros: concise, readable, uses built-in API.
	* Cons: may have performance overhead due to API usage.
2. **Map Reduce**
	* Pros: flexible, can be optimized for specific use cases.
	* Cons: requires manual implementation, can be less readable.
3. **JSON Parse with decodeURI**
	* Pros: easy to implement, uses standard JSON parsing.
	* Cons: may have performance overhead due to decoding and parsing.
4. **JSON Parse with decodeURIComponent**
	* Pros: custom decoding function can handle edge cases.
	* Cons: more complex implementation, may have performance overhead.

**Library and Custom Function**

The `URLSearchParams` API is a built-in library in modern JavaScript browsers that provides an easy way to parse URL query strings into JavaScript objects. The custom function used in the **JSON Parse with decodeURIComponent** approach (`function(key, value) { return key===\"\"?value:decodeURIComponent(value) }`) decodes the value of each key-value pair using `decodeURIComponent`.

**Special JS Features**

There are no special JS features or syntax mentioned in the benchmark. However, it's worth noting that the use of `URLSearchParams` and JSON parsing assumes modern browsers with support for these APIs.

**Alternatives**

Other alternatives to the approaches tested in this benchmark include:

* Using a library like jQuery.parseJSON() or a custom implementation of JSON parsing.
* Utilizing other query string parsing libraries, such as query-string-parser.
* Implementing a custom parser using a different algorithm or data structure.

Related benchmarks:

Url parameters to object (version: 0)

Comparing performance of: Object.entries with URLSearchParams vs map reduce vs json parse decodeURI vs json parse decodeURIComponent

Created: 4 years ago by: Guest

Jump to the latest result

Object.entries with URLSearchParams

map reduce

json parse decodeURI

json parse decodeURIComponent

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):