Benchmark: Url parameters to object

Script Preparation code:

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

AخA
 
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));
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;
        }, {});

 
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,'":"') + '"}')
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) })
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

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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: 16 days 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 5 months ago):

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:

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.
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.
JSON Parse with decodeURI: This approach uses decodeURI to decode the URL query string and then parses it as JSON using JSON.parse.
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:

Object.entries with URLSearchParams
- Pros: concise, readable, uses built-in API.
- Cons: may have performance overhead due to API usage.
Map Reduce
- Pros: flexible, can be optimized for specific use cases.
- Cons: requires manual implementation, can be less readable.
JSON Parse with decodeURI
- Pros: easy to implement, uses standard JSON parsing.
- Cons: may have performance overhead due to decoding and parsing.
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.

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