Benchmark: Partial base, search, fragment of URL 2

Script Preparation code:

var url1 = "https://localhost:3000/test?key1=value1&key2=value2#test";

const urlPattern = /^(https?:\/\/[^\/?#]+[^?#]*)?(?:\?([^#]*))?(?:#([^?]*))?(?:\?([^#]*))?/;

function extractParts1(inputUrl) {
    const match = inputUrl.match(urlPattern);
    if (!match) return null;

    let url = match[1] || null;
    let searchParams = match[2] || null;
    let fragment = match[3] || null;
    // If there are query parameters after the fragment
    if (match[4]) {
        searchParams = searchParams ? searchParams + '&' + match[4] : match[4];
    }

    return {
        url,
        searchParams,
        fragment
    };
}


function extractParts2(inputUrl) {
    // Parse basic URL and fragment
    const [base, fragmentQuery] = inputUrl.split('#');
    
    // Parse URL and search parameters from base
    let [url, searchParams] = base.split('?');

    // If there's fragment data, check for additional query parameters
    let fragment = null;
    let extraSearchParams = null;
    if (fragmentQuery) {
        if (fragmentQuery.includes('?')) {
            [fragment, extraSearchParams] = fragmentQuery.split('?');
            searchParams = searchParams ? `${searchParams}&${extraSearchParams}` : extraSearchParams;
        } else {
            fragment = fragmentQuery;
        }
    }

    return {
        url,
        searchParams: searchParams || null,
        fragment: fragment || null
    };
}


function extractParts3(inputUrl) {
    const queryIndex = inputUrl.indexOf('?');
    const hashIndex = inputUrl.indexOf('#');

    const hasQueryBeforeHash = queryIndex !== -1 && (hashIndex === -1 || queryIndex < hashIndex);

    const url = hasQueryBeforeHash ? inputUrl.substring(0, queryIndex) : (hashIndex !== -1 ? inputUrl.substring(0, hashIndex) : inputUrl);

    let searchParams = null, fragment = null;

    if (hashIndex !== -1) {
        const fragmentWithQuery = inputUrl.substring(hashIndex + 1);
        const fragmentQueryIndex = fragmentWithQuery.indexOf('?');

        if (fragmentQueryIndex !== -1) {
            fragment = fragmentWithQuery.substring(0, fragmentQueryIndex);
            searchParams = fragmentWithQuery.substring(fragmentQueryIndex + 1);
            if (hasQueryBeforeHash) {
                searchParams = inputUrl.substring(queryIndex + 1, hashIndex) + '&' + searchParams;
            }
        } else {
            fragment = fragmentWithQuery;
        }
    }

    if (hasQueryBeforeHash && !searchParams) {
        searchParams = hashIndex !== -1 ? inputUrl.substring(queryIndex + 1, hashIndex) : inputUrl.substring(queryIndex + 1);
    }

    return {
        url,
        searchParams: searchParams || null,
        fragment: fragment || null
    };
}

function extractParts4(inputUrl) {
    return new URL(inputUrl);
}

Tests:

patern 1
extractParts1(url1);
patern 2
extractParts2(url1);
patern 3
extractParts3(url1);
patern 4
extractParts4(url1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
patern 1
patern 2
patern 3
patern 4

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Opera 102 on Windows

View result in a separate tab

Test name	Executions per second
patern 1	7866830.5 Ops/sec
patern 2	8502115.0 Ops/sec
patern 3	10796531.0 Ops/sec
patern 4	1587717.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its various components.

**Benchmark Definition**

The benchmark is designed to measure the performance of four different approaches for extracting URL parts (url, search parameters, and fragment) from a given input URL.

**Options Compared**

The four options compared are:

1. `extractParts1(inputUrl)`: This function uses a regular expression to match the URL pattern and extract the individual parts.
2. `extractParts2(inputUrl)`: This function splits the URL into two parts: basic URL (base) and fragment query, and then parses the search parameters from the base part.
3. `extractParts3(inputUrl)`: This function uses a more complex approach to parse the URL, considering both query parameters and hash fragments.
4. `extractParts4(inputUrl)`: This function uses the built-in `URL` API to extract the individual parts of the URL.

**Pros and Cons**

Here's a brief summary of each option:

1. `extractParts1(inputUrl)`:
	* Pros: Simple, efficient, and well-supported.
	* Cons: May not work correctly for all edge cases (e.g., URLs with multiple fragments).
2. `extractParts2(inputUrl)`:
	* Pros: Easy to understand and implement, but may be slower due to string manipulation.
	* Cons: Less efficient than other options, especially for large inputs.
3. `extractParts3(inputUrl)`:
	* Pros: Handles more edge cases (e.g., URLs with multiple fragments), but is more complex.
	* Cons: May be slower and harder to maintain due to its complexity.
4. `extractParts4(inputUrl)`:
	* Pros: Fast, efficient, and well-supported, as it uses the built-in `URL` API.
	* Cons: Requires modern browsers or Node.js environment.

**Library/Functionality**

The `URL` API is used in `extractParts4(inputUrl)`. The `URL` interface provides a standardized way to parse URLs into their individual parts (protocol, hostname, pathname, search parameters, and hash).

**Individual Test Cases**

Each test case measures the performance of one specific option:

1. `patern 1`: `extractParts1(url1)`
2. `patern 2`: `extractParts2(url1)`
3. `patern 3`: `extractParts3(url1)`
4. `patern 4`: `extractParts4(url1)`

**Benchmark Result**

The latest benchmark result shows the performance metrics for each test case, including the number of executions per second.

In summary, the benchmark compares four different approaches for extracting URL parts and measures their performance in modern browsers or Node.js environments. The results can help identify which approach is most efficient and reliable.

Related benchmarks:

Partial base, search, fragment of URL 2 (version: 0)

Comparing performance of: patern 1 vs patern 2 vs patern 3 vs patern 4

Created: one year ago by: Guest

Jump to the latest result

patern 1

patern 2

patern 3

patern 4

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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